最近的题单【C++】-Toy模板网

这篇具有很好参考价值的文章主要介绍了最近的题单【C++】。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1.公共字串的计算

描述：给定两个只包含小写字母的字符串，计算两个字符串的最大公共子串的长度。

注：子串的定义指一个字符串删掉其部分前缀和后缀（也可以不删）后形成的字符串。

数据范围：字符串长度：1\le s\le 150\1≤s≤150

进阶：时间复杂度：O(n^3)\O(n3) ，空间复杂度：O(n)\O(n)

输入描述：

输入两个只包含小写字母的字符串

输出描述：

输出一个整数，代表最大公共子串的长度

示例1

输入：asdfas werasdfaswer
复制输出：6

1.1 思路

用find函数和string类里面的substr函数来从后面查找相同字串最后返回i则可以计算出来

1.2代码实现

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

void calculationstr(string s1,string s2)
{
    if(s1.size() < s2.size())
    {
        swap(s1,s2);
    }
    for(int i = s2.size();i >= 0;i--){
        for(int j = 0;j < s2.size() - i + 1;j++)
        {
            string str = s2.substr(j,i);
            if(s1.find(str) != s1.npos)
            {
                cout << i << endl;
                return;
            }
        }
    }
    return;
}
int main()
{
    string s1,s2;
    cin >> s1 >> s2;
    calculationstr(s1,s2);
}

1.1 思路

dp的话是也可以做的dp表的横纵坐标就是对应字符串的每一个单位的元素也就是dp[ i ][ j ];

i就是s1遍历到i时的字串j是s2遍历到j的子串所以看是否相等要看s1[ i ] 是否等于 s2[ j ] 如果等于的话则dp[ i ][ j ] = 前面一样的++；

1.2 代码实现

#include <iostream>
#include <vector>
#include <string>

using namespace std;

int calculationstr(const string  s1, const string  s2) {
    int m = s1.size();
    int n = s2.size();
    int max = 0;
    vector<vector<int>> dp (m, vector<int>(n, 0));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (s1[i] == s2[j]) {
                if (i >= 1 && j >= 1) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;

                } else {
                    dp[i][j] = 1;
                }
            }
            if (dp[i][j] > max) {
                max = dp[i][j];
            }
        }
    }
    return max;
}

int main() {
    string s1, s2;
    cin >> s1 >> s2;
    cout << calculationstr(s1, s2) << endl;
}

2.字符串反转

描述：接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

输入描述：

输入一行，为一个只包含小写字母的字符串。

输出描述：

输出该字符串反转后的字符串。

示例1输入：abcd 复制输出：dcba

1.1 思路

1.这题其实用algorithm里面的reverse函数就可以解决了；

2.或者双指针两个来交换是都可以的

1.2代码实现

方法1：

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

int main(){
    string s;
    cin >> s;
    reverse(s.begin(), s.end()); 
    cout << s;
    return 0;
}

方法2：

#include <iostream>
#include <string>
using namespace std;
string reversestr(string s1)
{
    if(s1.empty())
    {
        return 0;
    }
    size_t start = 0;
    size_t end = s1.size() - 1;
    while(start < end)
    {
        swap(s1[start],s1[end]);
        ++start;
        --end;
    }
    return s1;
}

int main() {
    string s;
    getline(cin,s);
    cout << reversestr(s) << endl;
}

3.小易的升级之路

描述：小易经常沉迷于网络游戏.有一次,他在玩一个打怪升级的游戏,他的角色的初始能力值为 a.在接下来的一段时间内,他将会依次遇见n个怪物,每个怪物的防御力为b1,b2,b3...bn. 如果遇到的怪物防御力bi小于等于小易的当前能力值c,那么他就能轻松打败怪物,并且使得自己的能力值增加bi;如果bi大于c,那他也能打败怪物,但他的能力值只能增加bi 与c的最大公约数.那么问题来了,在一系列的锻炼后,小易的最终能力值为多少?

输入描述：对于每组数据,第一行是两个整数n(1≤n<100000)表示怪物的数量和a表示小易的初始能力值. 然后输入n行，每行整数,b1,b2...bn(1≤bi≤n)表示每个怪物的防御力

输出描述：对于每组数据,输出一行.每行仅包含一个整数,表示小易的最终能力值

输入：3 50 50 105 200 5 20 30 20 15 40 100

输出：110 205

3.1 思路

这就是翻译题看上去很哇塞，其实也就是写一个求公约数的辗转相除就可以解决了，能力值大或者等于就直接+，小就加上他俩公约数就好了

3.2代码实现

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

int getnum(int a, int b) 
{ 
    int c = 0;
    while(a % b) 
    {
        c = a % b;
        a = b;
        b = c; 
    }
    return b;
}
int getpower(int n,int power)
{
    vector<int> num(n);
    for(int i = 0;i < n;i++)
    {
        cin >> num[i];
    }
    for(int i = 0;i < n;i++)
    {
        if(power >= num[i]){
            power += num[i];
        }
        else{
            power += getnum(power,num[i]);
        }
    }
    return power;
}
int main()
{   
    int n, a, power;
    while(cin >> n >> a) 
    { 
        power = getpower(n, a);
        cout << power << endl;
    }
        return 0;
}

4.找出字符串中第一个只出现一次的字符

描述：找出字符串中第一个只出现一次的字符

数据范围：输入的字符串长度满足 1 \le n \le 1000 \1≤n≤1000

输入描述：

输入一个非空字符串

输出描述：

输出第一个只出现一次的字符，如果不存在输出-1

输入：asdfasdfo

复制输出：o

4.1 思路

可以暴力揭发，之前做过一个类似也是用的哈希思想做的，我们先把这个hashtable一填写有的话++没有就是0，之后遍历只要里面是 1 直接就找到了，给数组里面放字符其实是他的阿斯克码值。

4.2 代码实现

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

int getfirstchar(const string  &s1)
{
    char ret;
    int hashtable[255] = {0};
    for(int i = 0;i < s1.size(); i++)
    {
        hashtable[s1[i]]++;
    }
    for(int i = 0;i < s1.size(); i++)
    {
        if(hashtable[s1[i]] == 1)
        {
            ret = s1[i];
            return ret;
        }
    }
    return -1; 
}
int main()
{
    string s1;
    char s;
    while(getline(cin,s1))
    {
        s = getfirstchar(s1);
        if(s == -1)
        {
            cout << -1 << endl;
        }
        else{
            cout << s << endl;
        }
    }
}

5. 计算字符串的编辑距离

描述：Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家 Levenshtein 提出的，故又叫 Levenshtein Distance 。

例如：字符串A: abcdefg字符串B: abcdef

通过增加或是删掉字符 ”g” 的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。

要求：给定任意两个字符串，写出一个算法计算它们的编辑距离。

数据范围：给定的字符串长度满足 1 \le len(str) \le 1000 \1≤len(str)≤1000

输入描述：每组用例一共2行，为输入的两个字符串

输出描述：每组用例输出一行，代表字符串的距离

输入：abcdefg abcdef

输出：1

5.1 思路

F(i,j): word1的前i个字符于word2的前j个字符的编辑距离 F(i,j) = min { F(i-1,j）+1, F(i,j-1) +1, F(i- 1,j-1) +(w1[i]==w2[j]?0:1) } 上式表示从删除，增加和替换操作中选择一个最小操作数 F(i-1,j):就可以解决了

5.2代码实现

#include <iostream>
#include <string>
using namespace std;
int strdistance(const string &s1,const string &s2)
{
    int m = s1.size();
    int n = s2.size();
    int dp[m + 1][n + 1];

    for(int i = 0;i < m + 1;i++)
    {
        dp[i][0] = i;
    }
    for(int j = 0;j < n + 1;j++)
    {
        dp[0][j] = j;
    }
    for(int i = 1;i < m + 1;i++)
    {
        for(int j = 1;j < n + 1;j++)
        {
            int op1 = dp[i - 1][j] + 1; //删除
            int op2 = dp[i][j - 1] + 1;
            int op3 = dp[i - 1][j - 1];
            if(s1[i - 1] != s2[j - 1])
            {
                op3++;
            }
            dp[i][j] = min(min(op1,op2),op3);
        }
    }
    return dp[m][n];

}

int main()
{
    string s1,s2;
    while(cin>>s1>>s2){
    cout<<strdistance(s1, s2)<<endl;
    return 0;
    }
}

6.微信红包

描述:春节期间小明使用微信收到很多个红包，非常开心。在查看领取红包记录时发现，某个红包金额出现的次数超过了红包总数的一半。请帮小明找到该红包金额。写出具体算法思路和代码实现，要求算法尽可能高效。

给定一个红包的金额数组 gifts 及它的大小 n ，请返回所求红包的金额。

若没有金额超过总数的一半，返回0。

数据范围： 1 \le n \le 1000 \1≤n≤1000 ,红包金额满足 1 \le gift_i \le 100000\1≤gifti≤100000

输入：[1,2,3,2,2],5

返回值：2

6.1思路

其实就是数组中出现一半数字的变种还是一个问题排序之后必定在中间。

6.2代码实现

class Gift {
public:
    int getValue(vector<int> gifts, int n) {
        sort(gifts.begin(),gifts.end());
        int mid = n >> 1;
        int count = 0;
        for(int i = 0;i < n;i++)
        {
            if(gifts[i] == gifts[mid])
            {
                count++;
            }
        }
        if(count > mid)
        {
            return gifts[mid];
        }
        else{
            return 0;
        }
    }
};

7. 年终奖

小东所在公司要发年终奖，而小东恰好获得了最高福利，他要在公司年会上参与一个抽奖游戏，游戏在一个6*6的棋盘上进行，上面放着36个价值不等的礼物，每个小的棋盘上面放置着一个礼物，他需要从左上角开始游戏，每次只能向下或者向右移动一步，到达右下角停止，一路上的格子里的礼物小东都能拿到，请设计一个算法使小东拿到价值最高的礼物。

给定一个6*6的矩阵board，其中每个元素为对应格子的礼物价值,左上角为[0,0],请返回能获得的最大价值，保证每个礼物价值大于100小于1000。

7.1 思路

剑指offer 47 里面的礼物最大总和那个题是一模一样的就把dp表按照走的方式填好，最后更替最大的值

7.2代码实现

class Bonus {
public:
    int getMost(vector<vector<int> > grid) {
    int m = grid.size();
    int n = grid[0].size(); 
    for(int i = 1; i < m; i++)
    {
       grid[i][0] += grid[i - 1][0];
    }
    for(int j = 1; j < n; j++)
    {
        grid[0][j] += grid[0][j - 1];
    }
    for(int i = 1;i < m; i++)
    {
        for(int j = 1; j < n; j++)
        {
            grid[i][j] += max(grid[i][j-1],grid[i-1][j]);
        }
    }
    return grid[m - 1][n - 1];
    }
};

8. 迷宫问题

定义一个二维数组 N*M ，如 5 × 5 数组下所示：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。

数据范围： 2 \le n,m \le 10 \2≤n,m≤10 ，输入的内容只包含 0 \le val \le 1 \0≤val≤1

输入描述：输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

输出描述：左上角到右下角的最短路径，格式如样例所示。

输入：

复制输出：

(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

8.1思路

这里用的递归没有用dp其实还是dfs的思想用一个数组来把这对路径存着一次次试探迷宫回溯

8.2代码实现

#include <iostream>
#include <vector>
using namespace std;
int row;
int col;
vector<vector<int>> maze;
vector<vector<int>> path;
vector<vector<int>> temp;

void gomaze(int i,int j)
{
    maze[i][j] = 1;
    temp.push_back({i,j});
    if(i == row - 1 && j == col -1)
    {
        if(path.empty() || path.size() > temp.size())
        {
            path = temp;
        }
    }

    if(i + 1 < row && maze[i + 1][j] == 0)
    {
        gomaze(i + 1,j);
    }

    if(i - 1 >= 0 && maze[i - 1][j] == 0)
    {
        gomaze(i - 1,j);
    }

    if(j + 1 < col && maze[i][j + 1] == 0)
    {
        gomaze(i,j + 1);
    }

    if(j - 1 >= 0 && maze[i][j - 1] == 0)
    {
        gomaze(i,j - 1);
    }
    maze[i][j] = 0;
    temp.pop_back();
}


int main() {
    while(cin >> row >> col)
    {
        maze = vector<vector<int>> (row,vector<int>(col,0));
        temp.clear();
        path.clear();
        for(int i = 0;i < row; ++i)
        {
            for(int j = 0;j < col; ++j)
            {
                cin >> maze[i][j];
            }
        }

        gomaze(0,0);

        for(int i = 0;i < path.size();++i)
        {
            cout << "(" << path[i][0] << "," << path[i][1] << ")" << endl;
        }
    }
    return 0;
}

9. 数根

数根可以通过把一个数的各个位上的数字加起来得到。如果得到的数是一位数，那么这个数就是数根；如果结果是两位数或者包括更多位的数字，那么再把这些数字加起来。如此进行下去，直到得到是一位数为止。
比如，对于24 来说，把2 和4 相加得到6，由于6 是一位数，因此6 是24 的数根。
再比如39，把3 和9 加起来得到12，由于12 不是一位数，因此还得把1 和2 加起来，最后得到3，这是一个一位数，因此3 是39 的数根。
现在给你一个正整数，输出它的数根。

9.1思路

先求和让数数量级先降下来，在一次次取数字一次次加直到小于10

9.2代码实现

#include<iostream>
#include<string>
using namespace std;
int getnum(int num)
{
    int sum = 0;
    while(num > 0)
    {
        sum += num % 10;
        num /= 10;
    }
    while(sum > 9)
    {
        sum = getnum(sum);
    }
    return sum;
}
int main()
{
    string s1;
    while(cin >> s1)
    {
        int sum = 0;
        for(auto e : s1)
        {
            sum += e - '0';
        }
        cout << getnum(sum) << endl;
    }
}

10. 星际密码

星际战争开展了100年之后，NowCoder终于破译了外星人的密码！他们的密码是一串整数，通过一张表里的信息映射成最终4位密码。表的规则是：n对应的值是矩阵X的n次方的左上角，如果这个数不足4位则用0填充，如果大于4位的则只输出最后4位。
|1 1|^n => |Xn ..|
|1 0| |.. ..|
例如n=2时，
|1 1|^2 => |1 1| * |1 1| => |2 1|
|1 0| |1 0| |1 0| |1 1|
即2对应的数是“0002”。

10.1 思路

其实就是算斐波那契数列左上角的数字

10.2代码实现文章来源地址https://www.toymoban.com/news/detail-417145.html

#include<iostream>
using namespace std;
int main()
{
    int fib[10001] ={1,1,2};
    for(int i = 3;i < 10001;i++)
    {
        fib[i] = fib[i - 1] + fib[i - 2];
        fib[i] %= 10000;
    }
    int n = 0;
    int m = 0;
    while(cin >> n)
    {
        while(n--)
        {
            cin >> m;
            printf("%04d",fib[m]);
        }
        printf(""\n);
    }
}

到了这里，关于最近的题单【C++】的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！