LeetCode题解(Week 9):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 player 1 can win.

Note:

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

中文大意：

有一个数组长度为N的数组nums，两个玩家player1和player2，每一个玩家每次都从nums的两端（头或尾）中取一个数字，player1先取，并且每一个玩家都以最大化自己取到的数字的和为目的，问是否存在一种策略使得player1能赢？

题解：

class Solution {
public:
    bool PredictTheWinner(vector<int>& nums) {
        int n = nums.size();
        vector<vector<int> > dp(n,vector<int>(n,0));
        int sum = 0;
        for(int i = 0;i<n;i++)
        {
            sum += nums[i];
            dp[i][i] = nums[i];
        }
        for(int i=1;i<n;i++)
            dp[i-1][i] = max(nums[i],nums[i-1]);
        for(int i = n-3;i>=0;i--)
        {
            for(int j = i+2;j<n;j++)
            {
                int ri = nums[i] + min(dp[i+1][j-1],dp[i+2][j]);
                int rj = nums[j] + min(dp[i+1][j-1],dp[i][j-2]);
                dp[i][j] = max(ri,rj);
            }
        }        
        return dp[0][n-1] >= sum - dp[0][n-1];
    }
};

解题思路：

这道题目可以利用动态规划来解决。假设nums的长度为n，记dp(i,j)为nums[i…j]中player1能够取到的最大分数。

• 显然dp(i,i),i=0…n-1
• dp(i-1,i) = max(nums[i-1],nums[i]) （当有两个数可以选的时候，选最大的数）
• 除去上述的两种情况以外：
  
  • 记ri = (当player1取了nums[i]得到的分数)，有ri = nums[i] + min{dp(i+1,j-1),dp(i+2,j)},由来：因为当取了nums[i]之后，player可以取nums[i+1]或者nums[j]，如果取了nums[i+1]，那么player得到的分数为dp(i+2,j)，否则为dp(i+1,j-1)，关键是，player2是不会轻易让player1拿到二者之间的最大值的，所以最终他只能得到这二者之间的较小值
  • 记rj = (当player1取了nums[j]得到的分数)，有rj = nums[j] + min{dp(i,j-2),dp(i+1,j-1)}
  • 最终取ri与rj的较大值，即dp(i,j) = max{ri,rj}
• 在思考的过程中，很困惑的一点是这样的动态规划的方向：最终的player1得到的分数必然是dp(0,n-1)，而它依赖于dp(1,n-2)以及dp(2,n-1)，以此类推，可以看到，i必须从后往前；而j需要从i往后，表示以i为开头的子序列逐渐扩大。因此，i从n-3到0；j从i+2到n-1