LC 1140. 石子游戏 II

1140. 石子游戏 II

难度 中等

题目大意:

爱丽丝和鲍勃继续他们的石子游戏。许多堆石子 排成一行，每堆都有正整数颗石子 piles[i]。游戏以谁手中的石子最多来决出胜负。

爱丽丝和鲍勃轮流进行，爱丽丝先开始。最初，M = 1。

在每个玩家的回合中，该玩家可以拿走剩下的 前 X 堆的所有石子，其中 1 <= X <= 2M。然后，令 M = max(M, X)。

游戏一直持续到所有石子都被拿走。

假设爱丽丝和鲍勃都发挥出最佳水平，返回爱丽丝可以得到的最大数量的石头。

提示：

• 1 <= piles.length <= 100
• 1 <= piles[i] <= 10^4

示例 1：

输入：piles = [2,7,9,4,4]
输出：10
解释：如果一开始Alice取了一堆，Bob取了两堆，然后Alice再取两堆。爱丽丝可以得到2 + 4 + 4 = 10堆。如果Alice一开始拿走了两堆，那么Bob可以拿走剩下的三堆。在这种情况下，Alice得到2 + 7 = 9堆。返回10，因为它更大。

思路1

定义：f[i][m]表示从第i堆开始，M = m的情况下，先手可以比后手多拿的最大石子数,当i == n的时候，那么f[i][m] = 0,因为已经没有石头可以取了， 其他的情况，我们要枚举x，状态转移是f[i][m] = max(f[i][m], sum - f[i + x][min(n, max(x, m))]); sum表示从i到i + x - 1这一段的和，转移完成之后，因为爱丽丝是先手，f[0][1]就表示爱丽丝比鲍勃多的石子数量，假设爱丽丝的总数是x，鲍勃的数量是y,也就是说x - y = f[0][1],又因为x + y = total_sum，所以联立这两个方程我们可以解得x = (f[0][1] + total_sum) / 2

代码实现

class Solution {
public:
    int stoneGameII(vector<int>& piles) {
        int n = piles.size(), total = 0;
        vector<vector<int>> f(n + 1, vector<int>(n + 1, INT32_MIN));
        for (int i = n; i >= 0; i --) {
            if (i < n) total += piles[i];
            for (int m = 1; m <= n; m ++) {
                if (i == n) f[i][m] = 0;
                else {
                    int sum = 0;
                    for (int x = 1; x <= 2 * m; x ++) {
                        if (i + x > n) break;
                        sum += piles[i + x - 1];
                        f[i][m] = max(f[i][m], sum - f[i + x][min(n, max(x, m))]);
                    } 
                }
            }
        }
        return total + f[0][1] >> 1;
    }
};

时间复杂度：$O(n^3)$

思路二

我们定义dfs(i, m)表示从第i堆石头开始，可以拿到的石子的最大值，如果可以全部拿走，也就是说i + 2 * m >= n的情况下，那么就全部拿走，直接返回后面的和，我们可以先预处理一个后缀和。因为二者都是最优策略，那么我们求一个可以得到石子的最小值，因为要自己尽可能多，而i确定的情况下，i后面的总和是不变的，所以我们要自己最大，也就是对手尽可能小即可，因为是最优策略，所以我们要石子尽可能多的情况下去一个最小值，用总和减去这个最小值，那么就是自己可以得到的最大值，dfs(0, 1)就是最终解

代码实现

class Solution {
public:
    int stoneGameII(vector<int>& piles) {
        int n = piles.size();
        vector<int> s(n + 1);
        for (int i = n - 1; i >= 0; i --) {
            s[i] = s[i + 1] + piles[i];
        }
        vector<vector<int>> f(n, vector<int>(n, -1));
        
        function<int(int, int)> dfs = [&](int i, int m) -> int {
            if (i + 2 * m >= n) return s[i];
            int& res = f[i][m];
            if (res != -1) return res;
            int mn = INT_MAX;
            for (int x = 1; x <= 2 * m; x ++) {
                // 表示以最优策略拿的情况下，对手可以获得的最少石头，对手石头最小，那么自己就最多
                mn = min(mn, dfs(i + x, max(x, m))); 
            }
            res = s[i] - mn; // 用总数减去这个最优的最小值
            return res;
        };
        return dfs(0, 1);
    }
};

时间复杂度: $O(n^3)$

记忆化翻译成递推

class Solution {
public:
    int stoneGameII(vector<int>& piles) {
        int n = piles.size();
        vector<vector<int>> f(n, vector<int>(n + 1));
        for (int i = n - 1, s = 0; i >= 0; i --) {
            s += piles[i];
            for (int m = 1; m <= i / 2 + 1; m ++) {
                if (i + 2 * m >= n) f[i][m] = s; // 如果可以全部拿下，那么直接全部拿下
                else {
                    int mn = INT_MAX;
                    for (int x = 1; x <= 2 * m; x ++) {
                        mn = min(mn, f[i + x][max(x, m)]);
                    }
                    f[i][m] = s - mn;
                }
            }
        }
        return f[0][1];
        
    }
};

时间复杂度: $O(n^3)$