JAVA程序设计：石子游戏 II（LeetCode：1140）

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

亚历克斯和李轮流进行，亚历克斯先开始。最初，M = 1。

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

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

假设亚历克斯和李都发挥出最佳水平，返回亚历克斯可以得到的最大数量的石头。

 

示例：

输入：piles = [2,7,9,4,4]
输出：10
解释：
如果亚历克斯在开始时拿走一堆石子，李拿走两堆，接着亚历克斯也拿走两堆。在这种情况下，亚历克斯可以拿到 2 + 4 + 4 = 10 颗石子。 
如果亚历克斯在开始时拿走两堆石子，那么李就可以拿走剩下全部三堆石子。在这种情况下，亚历克斯可以拿到 2 + 7 = 9 颗石子。
所以我们返回更大的 10。 
 

提示：

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

思路：在博弈问题中，为了达到胜利，对于每一轮的玩家来说，都要充分利用当前情况来获取最大利益，换句话说就是让对方尽可能的不赢，而本题的输赢评判标准是玩家能够获得的最大石子数量，我们考虑模拟整个取石子过程，游戏从第一轮开始，为了不失一般性，我们假设经历到了第i轮，并且当前玩家最多能够取x堆（2m>=x>=1）,此时要分情况讨论：

①此时没有石子了，游戏结束；

②当i+2m>=n时，呢当前玩家一定是取完所有石子的；

③当i+2m

方法一：针对上述思路，我们可以采用记忆化搜索来解决，dfs(i,m)表示在第i堆时，当前玩家可以取的堆数在[1,2m]之间的最优解。

class Solution {

    private int n;
    private int[] sum;
    private Map map;

    public int stoneGameII(int[] piles) {

        n = piles.length;
        sum = new int[n];
        map = new HashMap<>();

        sum[n - 1] = piles[n - 1];
        for (int i = n - 2; i >= 0; i--)
            sum[i] = sum[i + 1] + piles[i];

        return dfs(0, 1);

    }

    private int dfs(int i, int m) {

        String s = String.valueOf(i) + "#" + String.valueOf(m);

        if (map.containsKey(s)) return map.get(s);

        if (i >= n) return 0;

        if (i + 2 * m >= n) return sum[i];

        int res = 0;
        for (int x = 1; x <= 2 * m; x++)
            res = Math.max(res, sum[i] - dfs(i + x, Math.max(x, m)));

        map.put(s, res);

        return res;

    }
}

方法二：进一步优化，我们将记忆化搜索改为动态规划，思想不变。

class Solution {

    public int stoneGameII(int[] piles) {

        int sum = 0;
        int n = piles.length;
        int[][] dp = new int[n][n + 1];

        for (int i = n - 1; i >= 0; i--) {
            sum += piles[i];
            for (int m = 1; m <= n; m++) {
                if (i + 2 * m >= n) dp[i][m] = sum;
                else {
                    for (int x = 1; x <= 2 * m; x++)
                        dp[i][m] = Math.max(dp[i][m], sum - dp[i + x][Math.max(x, m)]);
                }
            }
        }

        return dp[0][1];

    }
}