Leetcode 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.

思路：

从题目可知，只要玩家1》=玩家2就表示玩家一赢，所以并不用将每次取的数都加起来，只要将每次玩家1和2所取的数相减取较大的那个差，然后将每次的差加起来就判断是否》=0即可。首先想到的是递归，定义函数partition，具体递归式如下：cache[beg][end] = beg == end ? nums[beg] : max(nums[beg] - partition(nums, beg + 1, end, cache), nums[end] - partition(nums, beg, end - 1, cache));

代码如下：

class Solution {
public:
    bool PredictTheWinner(vector<int>& nums) {
        vector<vector<int>> cache(nums.size());
        for (int i = 0; i < nums.size(); i ++){
            cache[i].resize(nums.size());
        }
        int ret = partition(nums, 0, nums.size() - 1, cache);
        return ret >= 0;
    }
    int partition(vector<int>& nums, int beg, int end, vector<vector<int>> cache){
        if (cache[beg][end] == NULL) {
            cache[beg][end] = beg == end ? nums[beg] : max(nums[beg] - partition(nums, beg + 1, end, cache), nums[end] - partition(nums, beg, end - 1, cache));
        }
        return cache[beg][end];
    }
};

然而超时了，只能想另一个办法。

使用动态规划，代码如下：

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