486. Predict the Winner

---

题目

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.

Note:
1 <= length of the array <= 20.
Any scores in the given array are non-negative integers and will not exceed 10,000,000.
If the scores of both players are equal, then player 1 is still the winner.

题目分析

两个人取数. player1可以取数组头或尾的数, 然后player2可以在剩下的数组中取头或尾的数, 以此类推, 问player1取的数的总和是否≥player2取的总和

算法分析

1. 只要求判断能不能赢, 所以将player2的得分理解成负值, player1为正值, 如果最后的和≥0, 说明player1的总分多于player2, player1获胜
2. 动态规划状态转移方程:
   设dp(i, j)记i, j之间取数能获得的最大值.
   那么$dp(i, j) = max(nums[i] - dp(i+1, j), nums[j] - dp(i, j-1) )$
   解读: 因为两个人都是按取最多的策略取数.所以当前取数的人是谁不必纠结.(理解这一点)
   那么dp(i, j)是怎么来的? 不妨设取数的人是A, A有两种取法:
   1) 取走nums[i], 那么剩下的数组为nums(i+1, j)
   · B肯定会在剩下的数组中取最大收益的那个, 所以A的这一步的收益就是当前收益nums[i] - B在剩下数组中的最大收益dp(i+1, j)
   · 此时dp(i, j) = nums[i] - dp(i+1, j)
   2) 取走nums[j], 那么剩下的数组为nums(i, j-1)
   · 同理
   · 此时dp(i, j) = nums[j] - dp(i, j-1)

时间复杂度$O(N^2)$
空间复杂度$O(N^2)$

具体实现

class Solution {
public:
    bool PredictTheWinner(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int>> dp(n, vector<int>(n));
        for (int i = 0; i < n; i++) dp[i][i] = nums[i];

        for (int len = 1; len < n; len++) {
            for (int j = 0; j + len < n; j++) {
                dp[j][j+len] = max(nums[j]-dp[j+1][j+len], nums[j+len]-dp[j][j+len-1]);
            }
        }
        return dp[0][n-1] >= 0;
    }
};

更贴近状态转移方程的写法(便于理解)

class Solution {
public:
    bool PredictTheWinner(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int>> dp(n, vector<int>(n));
        for (int i = 0; i < n; i++) dp[i][i] = nums[i];

        for (int len = 1; len < n; len++) {
            for (int i = 0; i + len < n; i++) {
                int j = i+len;
                dp[i][j] = max(nums[i]-dp[i+1][j], nums[j]-dp[i][j-1]);
            }
        }
        return dp[0][n-1] >= 0;
    }
};