486 Predict the Winner

1 题目

Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. The player with the maximum score wins.

Given an array of scores, predict whether player 1 is the winner. You can assume each player plays to maximize his score.

Example 1:

Input: [1, 5, 2]
Output: False
Explanation: Initially, player 1 can choose between 1 and 2. 
If he chooses 2 (or 1), then player 2 can choose from 1 (or 2) and 5. If player 2 chooses 5, then player 1 will be left with 1 (or 2). 
So, final score of player 1 is 1 + 2 = 3, and player 2 is 5. 
Hence, player 1 will never be the winner and you need to return False.

Example 2:

Input: [1, 5, 233, 7]
Output: True
Explanation: Player 1 first chooses 1. Then player 2 have to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233.
Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.

Input: [1, 5, 233, 7]
Output: True
Explanation: Player 1 first chooses 1. Then player 2 have to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233.
Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.

2 尝试解

2.1 分析

给定一个数组，A和B轮流从两端取走一个数，作为其得分。直到数组被取完，得分总和高的人获胜。若A和B均以最优策略游戏，问A是否能获胜。

Sum(i,j)表示当前数组A[i,...j]的所有数字之和，F(i,j)表示当前玩家可以从数组中获得的最大得分之和，该玩家有两种选择，取走左端或右端的数字，然后轮到对手面临从剩余数组中能获得的最大得分之和。

F(i,j) = max(Sum(i,j)-F(i+1,j),Sum(i,j)-F(i,j-1)) = Sum(i,j) - min(F(i+1,j),F(i,j-1))  (i <  j)

即在对手面临的两个子问题中，让对手能获得分数尽可能小，剩余的即为该玩家能获得的最大分数。

2.2 代码

class Solution {
public:
    bool PredictTheWinner(vector<int>& nums) {
        vector<vector<int>> saver(nums.size(),vector<int>(nums.size(),0));
        vector<int> sum(nums.size(),0);
        sum[0] = nums[0];
        for(int i = 1; i < nums.size(); i++) sum[i] = sum[i-1] + nums[i];
        return 2*MaxSum(nums,0,nums.size()-1,saver,sum)>=sum.back();
    }
    int MaxSum(vector<int>& nums,int s,int e,vector<vector<int>>& saver,vector<int>& sum){
        if(saver[s][e] > 0) return saver[s][e];
        if(s == e) return nums[s];
        int result = 0;
        result += sum[e] - (s?sum[s-1]:0);
        result -= min(MaxSum(nums,s+1,e,saver,sum),MaxSum(nums,s,e-1,saver,sum));
        saver[s][e] = result;
        return result;
    }
};

3 标准解

class Solution {
public:
    bool PredictTheWinner(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int>> dp(n, vector<int>(n)); // use to keep the score gap between player1 and player2
        for (int i = 0; i < n; i++) dp[i][i] = nums[i];
        for (int i = 1; i < n; i++) {
            for (int j = 0; j+i < n; j++) {
                dp[j][j+i] = max(nums[j+i]-dp[j][j+i-1], nums[j]-dp[j+1][j+i]);
            }
        }
        return dp[0][n-1] >= 0; // player1 get more score points than player2
    }
};