本⽂就借⽯头游戏来讲讲「假设两 个⼈都⾜够聪明，最后谁会获胜」这⼀类问题该如何⽤动态规划算法解决。
博弈类问题的套路都差不多，下⽂举例讲解，其核⼼思路是在⼆维 dp 的基 础上使⽤元组分别存储两个⼈的博弈结果。掌握了这个技巧以后，别⼈再问 你什么俩海盗分宝⽯，俩⼈拿硬币的问题，你就告诉别⼈：我懒得想，直接 给你写个算法算⼀下得了。
⼀、定义 dp 数组的含义
以下是对 dp 数组含义的解释：
dp[i][j].fir 表⽰，对于 piles[i...j] 这部分⽯头堆，先⼿能获得的最⾼分数。
dp[i][j].sec 表⽰，对于 piles[i...j] 这部分⽯头堆，后⼿能获得的最⾼分数。
举例理解⼀下，假设 piles = [3, 9, 1, 2]，索引从 0 开始
dp[0][1].fir = 9 意味着：⾯对⽯头堆 [3, 9]，先⼿最终能够获得 9 分。
dp[1][3].sec = 2 意味着：⾯对⽯头堆 [9, 1, 2]，后⼿最终能够获得 2 分。
我们想求的答案是先⼿和后⼿最终分数之差，按照这个定义也就是
dp[0] [n-1].fir - dp[0] [n-1].sec ，即⾯对整个 piles，先⼿的最优得分和后⼿的 最优得分之差。
dp 数组最终的样⼦：
下⽂讲解时，认为元组是包含 first 和 second 属性的⼀个类，⽽且为了节省
篇幅，将这两个属性简写为 fir 和 sec。⽐如按上图的数据，我们说
dp[1] [3].fir = 10 , dp[0] [1]sec = 3
⼆、状态转移⽅程
可以做的选择有两个：选择最左边的那堆⽯头，
或者选择最右边的那堆⽯头。 我们可以这样穷举所有状态：
n = piles.length
for 0 <= i < n:
for j <= i < n:
for who in {fir, sec}:
dp[i][j][who] = max(left, right)
这道题的难点在于，两⼈是交替进⾏选择的，也就是说先⼿的选择会对 后⼿有影响
根据我们对 dp 数组的定义，很容易解决这个难点，写出状态转移⽅程：
dp[i][j].fir = max(piles[i] + dp[i+1][j].sec, piles[j] + dp[i][j-1].sec)
# 解释：dp[i][j].fir = max( 选择最左边的⽯头堆 , 选择最右边的⽯头堆 )
#c我作为先⼿，⾯对 piles[i...j] 时，有两种选择：
# 要么我选择最左边的那⼀堆⽯头，然后⾯对 piles[i+1...j]
# 但是此时轮到对⽅，相当于我变成了后⼿；
# 要么我选择最右边的那⼀堆⽯头，然后⾯对 piles[i...j-1]
# 但是此时轮到对⽅，相当于我变成了后⼿。
if 先⼿选择左边:
dp[i][j].sec = dp[i+1][j].fir
if 先⼿选择右边:
dp[i][j].sec = dp[i][j-1].fir
# 解释：我作为后⼿，要等先⼿先选择，有两种情况：
# 如果先⼿选择了最左边那堆，给我剩下了 piles[i+1...j]
# 此时轮到我，我变成了先⼿；
# 如果先⼿选择了最右边那堆，给我剩下了 piles[i...j-1]
# 此时轮到我，我变成了先⼿。
根据 dp 数组的定义，我们也可以找出 base case，也就是最简单的情况：
dp[i][j].fir = piles[i]
dp[i][j].sec = 0
其中 0 <= i == j < n
# 解释：i 和 j 相等就是说⾯前只有⼀堆⽯头 piles[i]
# 那么显然先⼿的得分为 piles[i]
# 后⼿没有⽯头拿了，得分为 0
这⾥需要注意⼀点，我们发现 base case 是斜着的，⽽且我们推算 dp[i] [j] 时 需要⽤到 dp[i+1] [j] 和 dp[i] [j-1]：
所以说算法不能简单的⼀⾏⼀⾏遍历 dp 数组，⽽要斜着遍历数组
三、代码实现
如何实现这个 fir 和 sec 元组呢，你可以⽤ python，⾃带元组类型；或者使 ⽤ C++ 的 pair 容器；或者⽤⼀个三维数组 dp[n][n][2] ，最后⼀个维度就 相当于元组；或者我们⾃⼰写⼀个 Pair 类：
class Pair {
int fir, sec;
Pair(int fir, int sec) {
this.fir = fir;
this.sec = sec;
}
}
然后直接把我们的状态转移⽅程翻译成代码即可，可以注意⼀下斜着遍历数组的技巧
/* 返回游戏最后先⼿和后⼿的得分之差 */
int stoneGame(int[] piles) {
int n = piles.length;
// 初始化 dp 数组
Pair[][] dp = new Pair[n][n];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
dp[i][j] = new Pair(0, 0);
// 填⼊ base case
for (int i = 0; i < n; i++) {
dp[i][i].fir = piles[i];
dp[i][i].sec = 0;
}
// 斜着遍历数组
for (int l = 2; l <= n; l++) {
for (int i = 0; i <= n - l; i++) {
int j = l + i - 1;
// 先⼿选择最左边或最右边的分数
int left = piles[i] + dp[i+1][j].sec;
int right = piles[j] + dp[i][j-1].sec;
// 套⽤状态转移⽅程
if (left > right) {
dp[i][j].fir = left;
dp[i][j].sec = dp[i+1][j].fir;
} else {
dp[i][j].fir = right;
dp[i][j].sec = dp[i][j-1].fir;
}
}
}
Pair res = dp[0][n-1];
return res.fir - res.sec;
}
完整代码
#include <iostream>
#include <utility>
#include <vector>
#include<stdlib.h>
using namespace std;
typedef pair<int,int> Pair;
int stoneGame(vector<int> piles) {
int n = piles.size();
// 初始化 dp 数组
vector<vector<Pair> > dp(n,vector<Pair>(n,make_pair(0, 0)));
// 填⼊ base case
for (int i = 0; i < n; i++) {
dp[i][i].first = piles[i];
dp[i][i].second = 0;
}
// 斜着遍历数组
for (int l = 2; l <= n; l++) {
for (int i = 0; i <= n - l; i++) {
int j = l + i - 1;
// 先⼿选择最左边或最右边的分数
int left = piles[i] + dp[i+1][j].second;
int right = piles[j] + dp[i][j-1].second;
// 套⽤状态转移⽅程
if (left > right) {
dp[i][j].first = left;
dp[i][j].second = dp[i+1][j].first;
} else {
dp[i][j].first = right;
dp[i][j].second = dp[i][j-1].first;
}
}
}
Pair res = dp[0][n-1];
return res.first - res.second;
}
int main(int argc, char **argv)
{
// vector<int> piles = {3,9,1,2};
vector<int> piles;
piles.push_back(3);
piles.push_back(9);
piles.push_back(1);
piles.push_back(2);
int res = stoneGame(piles);
cout<< res <<endl;
system("pause");
return 0;
}
四、最后总结
本⽂给出了解决博弈问题的动态规划解法。博弈问题的前提⼀般都是在两个 聪明⼈之间进⾏，编程描述这种游戏的⼀般⽅法是⼆维 dp 数组，数组中通 过元组分别表⽰两⼈的最优决策。
之所以这样设计，是因为先⼿在做出选择之后，就成了后⼿，后⼿在对⽅做 完选择后，就变成了先⼿。这种⾓⾊转换使得我们可以重⽤之前的结果，典 型的动态规划标志。