LeetCode：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.

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.

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.

思路：

按照题意，玩家1先从数组两端任取一个数，之后玩家2从除去已经被选了的数字外的数组两端任取一个数，以此类推。最终数字被选取完后，预测玩家1的分数是否等于或高于玩家2。
这道题我选择用“动态规划”来解题。
定义sum[i][j]为数组下标从i 到 j 之间数字的总和，它可以表示成sum[0][j] - sum[0][i-1] = sum[j] - sum[i-1]；
定义dp[i][j]为其中一位玩家在数组下标 从i 到 j 之间取数字能获得的最大值；
当玩家1获取第i个元素时，dp[i][j] = nums[i] + sum[i+1][j] - dp[i+1][j]（dp[i+1][j]表示玩家2在i+1到j之间获取数字的最大值），记为dp1；当玩家1获取第j个元素时，dp[i][j] = nums[j] + sum[i][j-1] - dp[i][j-1]（dp[i][j-1]表示玩家2在i到j-1之间获取数字的最大值），记为dp2。所以dp[i][j] = max(dp1，dp2)。最终判断玩家1选取的数字总和是否大于等于所有数字总和的一半即可。

代码：

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

        for (int i = 0; i < n; i++) {
            sum[i+1] = sum[i] + nums[i];
        }

        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < n-i+1; j++) {
                int k = i + j - 1;
                if (j == k) dp[j][k] = nums[j];
                else if(k == j-1) dp[j][k] = max(nums[j], nums[k]);
                else {
                    int dp1 = nums[j] + sum[k+1] - sum[j+1] - dp[j+1][k];
                    int dp2 = nums[k] + sum[k] - sum[j] - dp[j][k-1];
                    dp[j][k] = max(dp1, dp2);
                }
            }
        }
        return 2*dp[0][n-1] >= sum.back();
    }
};

参考博客：http://blog.csdn.net/hit0803107/article/details/54906572