题目来源
类似的题目:
题目描述
给定一个整型数组arr,代表数值不同的纸牌排成一条线, 玩家A和玩家B依次拿走每张纸牌, 规定玩家A先拿,玩家B后拿, 但是每个玩家每次只能拿走最左或最右的纸牌,
玩家A和玩家B都绝顶聪明。请返回最后获胜者的分数
测试样例:
- [1,2,100,4],4
返回:
- 101
题目解析
递归
假设先手去 a r r [ L . . . . R ] arr[L....R] arr[L....R]中拿牌,要得到最佳决策,假设为 f ( a r r , L , R ) f(arr, L, R) f(arr,L,R)(不要中途转换人)
- 如果L == R,直接得到分数 a r r [ L ] arr[L] arr[L]
- 否则,有两种情况:
- 拿走左边的牌,然后本人将会以后手的身份面对[L + 1, R]的局面: a r r [ L ] + g ( a r r , L + 1 , R ) arr[L] + g(arr, L + 1, R) arr[L]+g(arr,L+1,R)
- 拿走右边的牌,然后本人将会以后手的身份面对[L, R - 1]的局面: a r r [ R ] + g ( a r r , L , R − 1 ) arr[R] + g(arr, L , R - 1) arr[R]+g(arr,L,R−1)
- 作为绝顶聪明的人,必然会在两种决策中选择最优的。所以应该从上面决策中选一种大的: m a x ( a r r [ L ] + g ( a r r , L + 1 , R ) , a r r [ R ] + g ( a r r , L , R − 1 ) ) ; max(arr[L] + g(arr, L + 1, R), arr[R] + g(arr, L , R - 1)); max(arr[L]+g(arr,L+1,R),arr[R]+g(arr,L,R−1));
接下来我们分析 g ( a r r , L , R ) g(arr, L, R) g(arr,L,R),也就是以后手的方式去 a r r [ L . . . . R ] arr[L....R] arr[L....R]中拿牌,此时:
- 如果L == R,那么得到的分数是 0 0 0,因为当前是后手,这个牌一定会被先手拿走
- 否则
- 如果对方拿走了 a r r [ L ] arr[L] arr[L],那么此时你的分数是以先手的方式去拿: f ( a r r , L + 1 , R ) f(arr, L + 1, R) f(arr,L+1,R)
- 如果对方拿走了 a r r [ R ] arr[R] arr[R],那么此时你的分数是以先手的方式去拿: f ( a r r , L , R − 1 ) f(arr, L, R - 1) f(arr,L,R−1)
- 对手也是绝顶聪明的人,所以也会把最差的情况留给玩家(你不能做选择,对方会把最差的情况留给你,你只能接受)因此返回 m i n ( f ( a r r , L + 1 , R ) , f ( a r r , L , R − 1 ) ) ; min(f(arr, L + 1, R), f(arr, L, R - 1)); min(f(arr,L+1,R),f(arr,L,R−1));
- 对于主函数,有两种情况:
- 以先手的情况开场,得到的分数为: f ( a r r , 0 , a r r . s i z e ( ) − 1 ) f(arr, 0, arr.size() - 1) f(arr,0,arr.size()−1)
- 其后手的情况开场,得到的分数为: g ( a r r , 0 , a r r . s i z e ( ) − 1 ) g(arr, 0, arr.size() - 1) g(arr,0,arr.size()−1)
- 从上面两种决策中选择一个最优的
class Solution1{
// arr[L..R],先手获得的最好分数返回
int f(std::vector<int> &arr, int L, int R){
if(L == R){
return arr[L];
}
int p1 = arr[L] + g(arr, L + 1, R);
int p2 = arr[R] + g(arr, L, R - 1);
return std::max(p1, p2);
}
// arr[L..R],后手获得的最好分数返回
int g(std::vector<int> &arr, int L, int R){
if(L == R){
return 0;
}
int p1 = f(arr, L + 1, R);
int p2 = f(arr, L , R - 1);
return std::min(p1, p2);
}
public:
int win(std::vector<int> arr){
if(arr.empty()){
return 0;
}
int v1 = f(arr, 0, arr.size() - 1);
int v2 =g(arr, 0, arr.size() - 1);
return std::max(v1, v2);
}
};
备忘录算法
先分析依赖,分析依赖时请用一个具体的例子来搞
注意到f和g是相互依赖的,我们可以搞两张表。
置于表应该多大,可以通过分析上面可变参数的范围得出。由:
int f(int[] arr, int L, int R)
int g(int[] arr, int L, int R)
L的变化范围为0…N-1, R的变化范围是0…N-1,所以两张表:
std::vector<std::vector<int>> fmap(N, std::vector<int>(N, -1));
std::vector<std::vector<int>> gmap(N, std::vector<int>(N, -1));
// == -1表示没有算过
最终代码:
class Solution{
// arr[L..R],先手获得的最好分数返回
int f(std::vector<int> &arr, int L, int R, std::vector<std::vector<int>>&fmap, std::vector<std::vector<int>>&gmap){
if(fmap[L][R] != -1){
return fmap[L][R];
}
int ans = 0;
if(L == R){
ans = arr[L];
}else{
int p1 = arr[L] + g(arr, L + 1, R, fmap, gmap);
int p2 = arr[R] + g(arr, L, R - 1, fmap, gmap);
ans = std::max(p1, p2);
}
fmap[L][R] = ans;
return ans;
}
// arr[L..R],后手获得的最好分数返回
int g(std::vector<int> &arr, int L, int R, std::vector<std::vector<int>>&fmap, std::vector<std::vector<int>>&gmap){
if (gmap[L][R] != -1) {
return gmap[L][R];
}
int ans = 0;
if(L == R){
ans = 0;
}else{
int p1 = f(arr, L + 1, R, fmap, gmap); //你只能在留给你的位置中决策
int p2 = f(arr, L , R - 1, fmap, gmap);
ans = std::min(p1, p2); //对方会把最差的情况留给你
}
gmap[L][R] = ans;
return ans;
}
public:
int win(std::vector<int> arr){
if(arr.empty()){
return 0;
}
int N = arr.size();
std::vector<std::vector<int>> fmap(N, std::vector<int>(N, -1));
std::vector<std::vector<int>> gmap(N, std::vector<int>(N, -1));
int v1 = f(arr, 0, N - 1, fmap, gmap);
int v2 =g(arr, 0, N - 1, fmap, gmap);
return std::max(v1, v2);
}
};
动态规划
(1)画出两张表
- 表格应该多大,通过分析可变参数:
置于表应该多大,可以通过分析上面可变参数的范围得出。由:
int f(int[] arr, int L, int R)
int g(int[] arr, int L, int R)
- L的变化范围为0…N-1, R的变化范围是0…N-1,所以两张表:
std::vector<std::vector<int>> fmap(N, std::vector<int>(N, -1));
std::vector<std::vector<int>> gmap(N, std::vector<int>(N, -1));
// == -1表示没有算过
- 填写bash case :
int f(std::vector<int> &arr, int L, int R){
if(L == R){
return arr[L];
}
//...............
}
// arr[L..R],后手获得的最好分数返回
int g(std::vector<int> &arr, int L, int R){
if(L == R){
return 0;
}
//...............
}
- 标记target,看主函数是怎么调用的
int win(std::vector<int> arr){
//...............
int v1 = f(arr, 0, arr.size() - 1);
int v2 =g(arr, 0, arr.size() - 1);
return std::max(v1, v2);
}
得到表如下:
(3)因为arr[L…R],只有至少有一张牌可以选择是才有效(对角线),所以左下角是无效的(此时L > R)
(4)分析依赖
同理
所以,它应该利用对方的对角线,互相推导,逐步逼近右上角
class Solution{
public:
int win(std::vector<int> arr){
if(arr.empty()){
return 0;
}
int N = arr.size();
std::vector<std::vector<int>> fmap(N, std::vector<int>(N));
std::vector<std::vector<int>> gmap(N, std::vector<int>(N));
for (int i = 0; i < N; ++i) {
fmap[i][i] = arr[i];
gmap[i][i] = 0;
}
for (int startCol = 1; startCol < N; ++startCol) {
int L = 0, R = startCol;
while (R < N){
fmap[L][R] = std::max(arr[L] + gmap[L + 1][R], arr[R] + gmap[L][R - 1]);
gmap[L][R] = std::min(fmap[L + 1][R], fmap[L][R - 1]);
L++;
R++;
}
}
return std::max(fmap[0][N - 1], gmap[0][N - 1]);
}
};
int main(){
std::vector<int> arr { 5, 7, 4, 5, 8, 1, 6, 0, 3, 4, 6, 1, 7};
Solution b;
std::cout << b.win(arr) << "\n"; //32
}