算法：最后获胜者的分数

题目来源

• 牛客网：纸牌博弈

类似的题目：

• leetcode：486. 预测赢家

题目描述

给定一个整型数组arr，代表数值不同的纸牌排成一条线， 玩家A和玩家B依次拿走每张纸牌， 规定玩家A先拿，玩家B后拿， 但是每个玩家每次只能拿走最左或最右的纸牌，

玩家A和玩家B都绝顶聪明。请返回最后获胜者的分数

测试样例：

• [1,2,100,4],4

返回：

• 101

题目解析

递归

假设先手去$arr[L....R]$中拿牌，要得到最佳决策，假设为$f(arr,L,R)$（不要中途转换人）

• 如果L == R，直接得到分数$arr[L]$
• 否则，有两种情况：
  • 拿走左边的牌，然后本人将会以后手的身份面对[L + 1, R]的局面： $arr[L]+g(arr,L+1,R)$
  • 拿走右边的牌，然后本人将会以后手的身份面对[L, R - 1]的局面：$arr[R]+g(arr,L,R-1)$
  • 作为绝顶聪明的人，必然会在两种决策中选择最优的。所以应该从上面决策中选一种大的：$max(arr[L]+g(arr,L+1,R),arr[R]+g(arr,L,R-1));$

接下来我们分析$g(arr,L,R)$，也就是以后手的方式去$arr[L....R]$中拿牌，此时：

• 如果L == R，那么得到的分数是$0$，因为当前是后手，这个牌一定会被先手拿走
• 否则
  • 如果对方拿走了$arr[L]$，那么此时你的分数是以先手的方式去拿：$f(arr,L+1,R)$
  • 如果对方拿走了$arr[R]$，那么此时你的分数是以先手的方式去拿：$f(arr,L,R-1)$
  • 对手也是绝顶聪明的人，所以也会把最差的情况留给玩家（你不能做选择，对方会把最差的情况留给你，你只能接受）因此返回$min(f(arr,L+1,R),f(arr,L,R-1));$

• 对于主函数，有两种情况：
  • 以先手的情况开场，得到的分数为：$f(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

}