华为C++笔试：小华和小为在一个两个m列的糖果迷宫里，迷宫的每一个位置上都有对应得糖果数目a[i][j],他们只能向右或者向下移动的问题

题目：
小华和小为在一个两个m列的糖果迷宫里，迷宫的每一个位置上都有对应得糖果数目a[i][j],他们只能向右或者向下移动。小华和小为都将从左上方a[0[[0]位置出发，向右下角a[1，m-1]走去，每到一个位置都将吃掉这个位置上的糖果。假设小华先走，他走完后会吃模路过的糖果，然后小为才开始走，被小华吃掉的糖果，小为就能再吃了。小华希望小为吃掉最少的糖果总数，然后小为也希望在小华走完后自己能吃掉更多的糖果总数。请你帮忙计算小为最多可以吃掉多少糖果。

解答：
道题可以使用动态规划的方法来解决。我们可以定义一个二维数组dp，其中dp[i][j]表示从左上角到达位置(i, j)时，小华吃掉的糖果总数减去小为吃掉的糖果总数的最大差值。

首先，我们初始化dp[0][0]为糖果迷宫的第一个位置的糖果数目a[0][0]，即dp[0][0] = a[0][0]。然后，对于第一行和第一列的位置，我们可以根据上一个位置的dp值和当前位置的糖果数目来更新dp值。具体而言，对于第一行的位置(i, j)，我们有dp[0][j] = dp[0][j-1] + a[0][j]；对于第一列的位置(i, j)，我们有dp[i][0] = dp[i-1][0] + a[i][0]。

接下来，我们使用两个嵌套的循环来遍历剩余的位置。对于位置(i, j)，我们可以根据其上方和左方的位置的dp值来更新当前位置的dp值。具体而言，我们有dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + a[i][j]。

最后，小为吃掉的糖果总数就是小华吃掉的糖果总数加上dp[n-1][m-1]，即小为吃掉的糖果总数 = 小华吃掉的糖果总数 + dp[n-1][m-1]。

下面是C++代码的实现：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    int n, m;
    std::cout << "请输入迷宫的行数n和列数m: ";
    std::cin >> n >> m;

    std::vector<std::vector<int>> a(n, std::vector<int>(m));
    std::cout << "请输入糖果迷宫的糖果数目：" << std::endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            std::cin >> a[i][j];
        }
    }

    std::vector<std::vector<int>> dp(n, std::vector<int>(m));
    dp[0][0] = a[0][0];

    for (int i = 1; i < n; i++) {
        dp[i][0] = dp[i-1][0] + a[i][0];
    }

    for (int j = 1; j < m; j++) {
        dp[0][j] = dp[0][j-1] + a[0][j];
    }

    for (int i = 1; i < n; i++) {
        for (int j = 1; j < m; j++) {
            dp[i][j] = std::max(dp[i-1][j], dp[i][j-1]) + a[i][j];
        }
    }

    int totalCandiesForXiaoHua = dp[n-1][m-1];
    int totalCandiesForXiaoWei = totalCandiesForXiaoHua - dp[n-1][m-1] + a[n-1][m-1];

    std::cout << "小为最多可以吃掉的糖果总数为: " << totalCandiesForXiaoWei << std::endl;

    return 0;
}

我们首先输入迷宫的行数n和列数m，然后输入糖果迷宫的糖果数目。接着，我们使用动态规划的方法计算dp数组，并最终输出小为最多可以吃掉的糖果总数。

另一种方式：

#include <iostream>
#include <vector>
using namespace std;
int main() {
    int m;
    cin >> m;
    vector<vector<int>> a(2, vector<int>(m, 0));
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> a[i][j];
        }
    }
    vector<vector<int>> dp(2, vector<int>(m, 0));
    dp[0][0] = a[0][0];
    // 计算小华能够吃到的糖果总数
    for (int i = 0; i < 2; ++i) {
        for (int j = 1; j < m; ++j) {
            dp[i][j] = (dp[i][j - 1] + a[i][j]) % 1000000007;
        }
    }
    // 计算小为能够吃到的糖果总数
    for (int i = 1; i < 2; ++i) {
        for (int j = 0; j < m; ++j) {
            dp[i][j] = (dp[i][j] + dp[i - 1][j]) % 1000000007;
        }
    }
    cout << dp[1][m - 1] << endl;
    return 0;
}

这段代码首先接受输入的迷宫大小m，然后接受两个二维数组a，分别代表小华和小为的糖果数目。接着，我们初始化一个二维数组dp，用于存储小为能够吃到的糖果总数。首先计算小华能够吃到的糖果总数，然后计算小为能够吃到的糖果总数。最后输出小为在右下角能够吃到的糖果总数。
请注意，这段代码的时间复杂度为O(m)，因为它需要遍历整个迷宫。在最坏的情况下，这可能会导致接近2000ms的时间消耗，因此这段代码在时间限制内是可行的。同样，由于代码只使用了常数级别的额外空间（除了输入和输出），它也在内存限制内。