涉及game的问题，2个player,
现有几堆石头，每堆石头个数为piles[i],
刚开始M=1,
player1先拿石头，可以拿走前 x 堆（假设从第 i 堆开始拿，可以拿 i ~ i+x-1 堆），1 <= x <= 2M,
拿完之后，重置M=max(x, M),
然后player2开始拿，重复这个过程，直到所有的石头被拿完。
问player1最多可以拿多少个石头。
思路：
game理论就是min, max, 尽量做到自己max, 对手min。
枚举所有可能的情况，找到player1最多的石头。
假设从第 i 堆开始拿，
player1拿x堆，那么player1将会得到piles[i] + … + piles[i+x-1]个石头，
M更新为max(x, M),
那么下一次player2从 i+x 堆开始拿，最多拿 2*max(x,M) 堆。
直到石头被拿完。
要枚举所有的 1 <= x <= 2M,
同时M <= n (n为石头堆数），2M >= n-x时，可以一次性拿走剩下所有石头(x=2M时，可以拿完）。
方法1：DFS
用DFS模拟一次player1, player2交替拿石头的过程，
因为中间涉及到计算和的过程：piles[i] + … + piles[i+x-1]，
提前计算积分数组pileSum，那么piles[i] + … + piles[i+x-1] = pileSum[i] - pileSum[i+x] (从右到左求和)
dfs(pileSum, i, m, dp)表示player从第 i 堆开始拿x堆石头（遍历所有x），m为当前的M，
保证调用它的player能石头最大化。
dp[i][m]保存从第i堆开始拿，限制为m的最大可拿石头数，可以避免重复计算。
因为最后求的是player1最多拿多少个石头，所以用player1的视角来调用DFS.
player1先拿，从第0堆开始拿，M=1。
所以调用dfs(pileSum, 0, 1, dp)
现在假设到了第 i 堆，
player1从第i堆开始拿走x堆石头后，会得到piles[i] + … + piles[i+x-1]个石头，
pileSum计算的是从右到左的和，因此piles[i] + … + piles[i+x-1] = pileSum[i]-pileSum[i+x]
M更新为max(x, M)
player1拿完之后，player2从i+x堆开始拿，限制为新的M=max(x, M),
根据game理论，对于player2来说，它自己也要石头最大化，
所以从player2的视角调用DFS， dfs(pileSum, i+x, max(x,M), dp)
player2拿完之后，player1可以拿pileSum[i+x] - player2拿的部分,
这就得到了player1最后拿的石头数。
用player1的视角调用DFS时，DFS函数的内部也有player2视角调用的DFS，
反之player2的视角调用DFS时，内部也有player1调用的DFS，
这就解释了game理论中的min, max, 最大化自己，最小化对手。
class Solution {
int n = 0;
public int stoneGameII(int[] piles) {
n = piles.length;
int[][] dp = new int[n][n];
for (int i = n - 2; i >= 0; i--)
piles[i] += piles[i + 1];
return dfs(piles, 0, 1, dp);
}
private int dfs(int[] pileSum, int i, int m, int[][] dp) {
//x<=2m,如果i+2m>=n,说明可以一次取走剩下所有堆
if (i + 2 * m >= n)
return pileSum[i];
if (dp[i][m] > 0)
return dp[i][m];
int result = 0, take = 0;
for (int x = 1; x <= 2 * m; x++) {
take = pileSum[i] - pileSum[i + x]; //拿走前x堆
result = Math.max(result, take + pileSum[i + x] - dfs(pileSum, i+x, Math.max(x, m), dp));
}
dp[i][m] = result;
return result;
}
}
方法二：DP
上面的DFS可以看作top-down的过程，
那么DP就是一个bottom-up的过程。
效率的话DFS更快。
public int stoneGameII(int[] piles) {
final int n = piles.length;
if(n < 2) return piles[0];
int[][] dp = new int[n][n+1];
int sum = 0;
//dp[i][m]: i表示从第i堆开始拿，m表示当前M
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];
}