面试题打卡——C++版

Posted ych9527

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面试题打卡——C++版相关的知识,希望对你有一定的参考价值。

跳石板

小易来到了一条石板路前,每块石板上从1挨着编号为:1、2、3…
这条石板路要根据特殊的规则才能前进:对于小易当前所在的编号为K的 石板,小易单次只能往前跳K的一个约数(不含1和K)步,即跳到K+X(X为K的一个非1和本身的约数)的位置。 小易当前处在编号为N的石板,他想跳到编号恰好为M的石板去,小易想知道最少需要跳跃几次可以到达。
例如:
N = 4,M = 24:
4->6->8->12->18->24
于是小易最少需要跳跃5次,就可以从4号石板跳到24号石板

题解:

1.定义数组count[m]表示到达m位置时需要跳多少次,初始化数组的值为INT_MAX, count[n]=0

2.遍历count,如果count[i]!=INT_MAX,表示可以从当前位置出发(从第一次开始,跳到这来了)

3.当从 i位置,跳到下一个x位置时,count[x]=fmin(count[x],count[i]+1)

#include <iostream>
#include <vector>
using namespace std;
#include <math.h>
#include <limits.h>

void GetNum(int x, vector<int> &arr)//求下一步的所有值
{
	arr.clear();//先清空
	for (int i = 2; i <= sqrt(x); i++)//从后往前除,第一个位置就是最大值
	{
		if (x%i == 0)
		{
			arr.push_back(i);

			if (x / i != i)//另外一半
				arr.push_back(x / i);
		}
	}
}

int main()
{
	int n;//出发点
	int m;
	while (cin >> n)
	{
		cin >> m;//跳到m位置

		vector<int> count(m + 1, INT_MAX);//count[i]表示跳到i位置所需要的步伐数

		vector<int> arr;
        count[n]=0;

		for (int i = n; i <= m; i++)
		{
			if (count[i] ==INT_MAX)//不能从当前位置出发
				continue;

			GetNum(i, arr);//获取下一步能到达的位置

			for (auto&e : arr)
			{
				if (e + i <= m)//没有超出范围
				  count[i + e] = fmin(count[i + e], count[i] + 1);
			}
		}

		if (n == m)
			cout << 0 << endl;
		else if (count[m] == INT_MAX)
			cout << -1 << endl;
		else
			cout << count[m] << endl;
	}

	return 0;
}

字符串通配符

问题描述:在计算机中,通配符一种特殊语法,广泛应用于文件搜索、数据库、正则表达式等领域。现要求各位实现字符串通配符的算法。
要求: 实现如下2个通配符:
*:匹配0个或以上的字符(字符由英文字母和数字0-9组成,下同)
?:匹配1个字符

注意:匹配时不区分大小写。
输入: 通配符表达式; 一组字符串。

题解:

1.设dp[i][j]表示s1的前i个字符和s2的前j个字符是否匹配

2.此时s1的最后一个字符s1[i]有三种情况:为?、为*、为普通字符,接下来分别进行讨论

a.当s1[i]==?时,如果对方s2[j]是字母或者数字时,则表示匹配,即此时需要看两个字符串的前一个位置 dp[i][j]

b.当s1[i]==*,此时 * 可以匹配N个字符
当N=0时,当前是否匹配,则需要看s1的前i-1个字符和s2的前j个字符 -> dp[i+1][j+1] = dp[i][j+1]
当N!=0时,则需要判断s2[j]是否是字母或者数字,如果是,表示s1[i]可以和s2[j]进行匹配,此时需要看前面,以s1[i]和s2[j-1]结尾的字符串是否相等,因为此时N可以进行多次匹配

c.当s1[i]为普通字符时,此时则需要判断s1[i]是否与s2[j]相等,如果相等,则判断s[i-1] 与 s[j-1]是否相等

3.进行初始化的时候,dp[0][0]=true表示两个都为空时,同时需要判断s1[i] 是否是连续的*,如果是,则dp[i+1][0]=true -> * 可以为为0

#include <iostream>
using namespace std;
#include <string>
#include <vector>

bool Judge(string &str, int sub)
{
	if ((str[sub] >= '0'&&str[sub] <= '9') || (str[sub] >= 'a'&&str[sub] <= 'z') || (str[sub] >= 'A'&&str[sub] <= 'Z'))//*和.可以匹配的字符
		return true;
	return false;
}

int main()
{
	string s1, s2;
	while (cin >> s1 >> s2)
	{
		vector<vector<bool>> dp(s1.size() + 1, vector<bool>(s2.size() + 1, false));
		dp[0][0] = true;//两个都是空字符串

		for (int i = 0; i < s1.size(); i++)//*连续,则可以一直表示0个字符,即与空串是匹配的
		{
			if (s1[i] == '*')
				dp[i + 1][0] = true;
			else
				break;
		}

		for (int i = 0; i<s1.size(); i++)
		{
			for (int j = 0; j<s2.size(); j++)
			{
				if (s1[i] == '?')
				{
					if (Judge(s2, j))
						dp[i + 1][j + 1] = dp[i][j];
				}
				else if (s1[i] == '*')
				{
					if (dp[i][j + 1] == true)//匹配0个
						dp[i + 1][j + 1] = true;
					else if (Judge(s2, j))//匹配多个
						dp[i + 1][j + 1] = dp[i + 1][j];
				}
				else//普通字符
				{
					if (s1[i] == s2[j] || s1[i] - 32 == s2[j] || s1[i] + 32 == s2[j])
						dp[i + 1][j + 1] = dp[i][j];
				}
			}
		}
		if (dp[s1.size()][s2.size()])
			cout << "true" << endl;
		else
			cout << "false" << endl;
	}

	return 0;
}

串联字符串的最大长度

给定一个字符串数组 arr,字符串 s 是将 arr 某一子序列字符串连接所得的字符串,如果 s 中的每一个字符都只出现过一次,那么它就是一个可行解。请返回所有可行解 s 中最长长度。

题解:

1.利用回溯法,将字符进行组合起来

2.回溯的过程之中,进行剪枝 -> 当组合的字符串中出现重复的字符,则进行剪枝(可以用哈希表,进行是否字符重复判断)

3.当组成的字符串出现新的长度的时候,则保存起来

4.最后返回得到的字符串的长度

class Solution {
public:
    bool Judge(string &str)
    {
        unordered_map<char,int> mp;

        for(auto&e:str)
        {
            if(mp[e]==0)
                mp[e]++;
            else
                return false;//出现多次
        }
        return  true;
    }

    void _maxLength(string &ret,vector<string>& arr,int sub,string &temp)
    {
        if(!Judge(temp))//出现重复字符
            return ;

        if(temp.size()>ret.size())//出现了更长的字符
            ret=temp;        

        for(int i=sub;i<arr.size();i++)
        {
            string copy(temp);//先保存一份
            temp+=arr[i];
            _maxLength(ret,arr,i+1,temp);
            temp.swap(copy);//回溯处理
        }
    }

    int maxLength(vector<string>& arr) {
        //首先得判断是否有重复的字符
        //挑选出最长的不含重复字符的最长字符串,返回它的长度
        //利用回溯法,进行字符串的拼接,然后进行判断是否出现重复的字符

        string ret,temp;

        _maxLength(ret,arr,0,temp);
        return ret.size();
    }
};

柱状图中最大的矩形

给定 n 个非负整数,用来表示柱状图中各个柱子的高度。每个柱子彼此相邻,且宽度为 1 。求在该柱状图中,能够勾勒出来的矩形的最大面积。

题解1:暴力法

遍历整个数组,求出以每块木板的长度为矩形高度的面积,算出所有的值来,取其中的最大值

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        //遍历整个数组,求以每一块板为高度的面积
        int max=0;
        for(int i=0;i<heights.size();i++)
        {
            int left=i;
            int right=i;

            while(left>=0&&heights[left]>=heights[i])
                left--;
            
            while(right<heights.size()&&heights[right]>=heights[i])
                right++;
            
            max=fmax(max,heights[i]*(right-left-1));
        }
        return max;
    }
};

题解2:单调栈法

1.由暴力法可知,需要遍历每块板,然后找到它的左边边界(左边第一块小于当前板的位置)和右边边界(右边第一块长度小于当前板的位置)

2.维护一个单调栈,如果新入的元素大于等于栈顶元素,则将其入栈

3.如果新入的元素小于栈顶元素,则将栈顶元素出栈,此时,新入元素的位置就是右边界,由于是单调递增栈,栈中下一个位置就是左边界

4.由于边界的判定需要,所以栈中保存的是元素的坐标

5.同时,当栈为空或者一些特殊情况非常麻烦,因此在数组的前面和后面分别加上一个0

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        //在前面和后面添加0,解决一些场景下的边界问题
        vector<int> copy(heights.begin(),heights.end());
        copy.insert(copy.begin(),0);
        copy.push_back(0);

        int max=0;
        for(int i=0;i<copy.size();i++)
        {
            //新来的元素,小于栈顶元素
            while(!st.empty()&&copy[i]<copy[st.top()])
            {
                int cur=st.top();
                st.pop();
                int left=st.top();
                max=fmax(max,(i-left-1)*copy[cur]);
            }
            st.push(i);
        }

        return max;
    }

    stack<int> st;
};

皇位继承顺序

一个王国里住着国王、他的孩子们、他的孙子们等等。每一个时间点,这个家庭里有人出生也有人死亡。这个王国有一个明确规定的皇位继承顺序,第一继承人总是国王自己。我们定义递归函数 Successor(x, curOrder) ,给定一个人 x 和当前的继承顺序,该函数返回 x 的下一继承人。

题解:

1.给定两个哈希表,一个mp<string,vector>存储具有继承关系的人,mp中key值表示以这个人为父亲,v值表示这个人孩子的集合
另外一个set记录这个人是否已经死了,如果一个人死了,则添加至set集合之中

2.新孩子来了,通过父亲找到对应的集合,将孩子添加进去

3.输出继承顺序,继承顺序是一个前序遍历,在输出的时候,需要判断,这个人是否在死亡集合里面
在这里插入图片描述

class ThroneInheritance {
public:
    ThroneInheritance(string kingName)
    :_king(kingName)
    {
        _mp[kingName];//第一个人
    }
    
    void birth(string parentName, string childName) {//有了一个新的孩子
        
        //得到它父亲的孩子集合,并且将该孩子添加进去
       _mp[parentName].push_back(childName);//将该孩子添加进去

        _mp.insert(make_pair(childName,vector<string>()));//这个孩子也有可能成为父亲
    }
    
    void death(string name) {//死了
        _death.insert(name);//死亡的将其进行标记
    }

    void prevOrder(vector<string>& ret,string name)
    {
        vector<string> arr=_mp[name];
        for(int i=0;i<arr.size();i++)
        {
            if(_death.find(arr[i])==_death.end())//没有死亡,则添加进去
                ret.push_back(arr[i]);
            
            prevOrder(ret,arr[i]);
        }
    }
    
    vector<string> getInheritanceOrder() {//返回继承顺序列表
        vector<string> ret;

        if(_death.find(_king)==_death.end())//不在死亡列表之中
            ret.push_back(_king);
        
        prevOrder(ret,_king);

        return ret;
    }
    
    string _king;//保存第一位国王
    unordered_map<string,vector<string>> _mp;//记录每个人,和它的孩子
    unordered_set<string> _death;//记录这个人是否死亡
};

以上是关于面试题打卡——C++版的主要内容,如果未能解决你的问题,请参考以下文章

面试题打卡——C++版

面试题打卡——C++版

面试题打卡——C++版

面试题打卡——C++版

面试题打卡——C++版

C++经典面试题打卡