2024.08.31京东

1. 字符串谜题

小明获得了一项任务，任务是一个谜题，谜题的答案是一个长度为N的字母串。
小明试图寻找答案，整理出所有的字符串。为了不重复，他萌生了按字典序浏览单词的想法。
但是小明已经厌倦了手动计算每个字符串的下一个字符串，所以他想让你帮助他编写一个程序自动化实现这个过程。
编写一个程序，根据输入的字母串，按字典序输出下一个单词(长度相同)

点击查看代码

int main() {
    string s;
    cin>>s;
    int idx = s.size()-1;
    while(idx>=0){
        if(s[idx]=='z'){
            s[idx]='a';
            idx--;
        }
        else{
            s[idx]+=1;
            break;
        }
    }
    if(idx==-1) cout<<-1<<endl;
    else cout<<s<<endl;
    return 0;
}

2. 最小化操作次数

给出一个几个互不相同的非负整数，最初是无序的，
现在有两种操作:选择两个连续的数字，然后反转他们的位置，比如「1,2会变成2，
1选择三个连续的数字，然后反转他们的位置，比如「1,2,3会变成3,2,1可以证明，
在有限次以上两种操作下，一定可以将数列变为有序。
但是如果一直进行第一种操作，那不就变成冒泡排序了吗，所以你要最小化第一种操作的次数。

思维题

int main() {
    int n;
    cin>>n;
    vector<int> nums(n);
    unordered_map<int,int> m;
    for(int i=0;i<n;i++){
        cin>>nums[i];
        m[nums[i]] = i%2;
    }
    //交换相邻的，交换间隔一个的无限次，只用看对应数排序后，如果同是奇数或者偶数位，就不用使用操作1
    sort(nums.begin(),nums.end());
    int res = 0;
    for(int i=0;i<n;i++)
        res += (i%2!=m[nums[i]]);
    cout<<res/2;
    return 0;
}

3. 轮流走方格

给定一个2行 N列的矩阵。一个有效的路径为从起点(1,1)出发，经过向上、向下或向右的移动，不重复访问同一个方格，最终到达终点(2,N)
现在有两名玩家，他们轮流选择路径上的下一个方格(游戏从第一个玩家选择方格(1,1)开始)。当路径到达终点(2,N)时，游戏停止。
路径的成本定义为路径上所有方格上数字的总和。第一个玩家希望最大化路径的成本，而第二个玩家希望最小化路径的成本。如果两个玩家都采取最优策略，路径的成本将是多少?

动态规划，写优雅还是稍微要动点脑筋

int main() {
    int n;
    cin>>n;
    vector<vector<int>> grid(2,vector<int>(n));
    for(int i=0;i<2;i++)
        for(int j=0;j<n;j++)
            cin>>grid[i][j];
    //dpmx[i][j]表示玩家一以（i,j）为终点的最大代价
    vector<vector<int>> dpmx(2,vector<int>(n,INT_MIN));//只能从玩家二转移
    vector<vector<int>> dpmn(2,vector<int>(n,INT_MAX));//只能从玩家一转移
    //初始化边界
    dpmx[0][0] = grid[0][0]; //玩家一的最大代价
    dpmn[1][0] = dpmx[0][0] + grid[1][0]; //玩家二的最小代价
    for(int i=1;i<n;i++){

        //首先从左边转移
        if(dpmn[0][i-1]!=INT_MAX) dpmx[0][i] = dpmn[0][i-1]+grid[0][i];
        if(dpmx[0][i-1]!=INT_MIN) dpmn[0][i] = dpmx[0][i-1]+grid[0][i];
        if(dpmn[1][i-1]!=INT_MAX) dpmx[1][i] = dpmn[1][i-1]+grid[1][i];
        if(dpmx[1][i-1]!=INT_MIN) dpmn[1][i] = dpmx[1][i-1]+grid[1][i];

        int tmx0 = dpmx[0][i];
        int tmn0 = dpmn[0][i];
        int tmx1 = dpmx[1][i];
        int tmn1 = dpmn[1][i];
        //接着从上下转移，这里避免重复路径，所以要用之前暂存的只进行过向右转移的来比较
        if(tmn1!=INT_MAX) dpmx[0][i] = max(dpmx[0][i],tmn1+grid[0][i]);
        if(tmx1!=INT_MIN) dpmn[0][i] = min(dpmn[0][i],tmx1+grid[0][i]);
        if(tmn0!=INT_MAX) dpmx[1][i] = max(dpmx[1][i],tmn0+grid[1][i]);
        if(tmx0!=INT_MIN) dpmn[1][i] = min(dpmn[1][i],tmx0+grid[1][i]);
    }
    if(n%2==1)
        cout<<dpmn[1][n-1]<<endl;
    else 
        cout<<dpmx[1][n-1]<<endl;
    return 0;
}