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.

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.

给出一个数组，玩家1先选数字，每次只能从数组首尾两端选，选过的数字不能再选，玩家1和玩家2轮流选数字，最后所选数字的和较大的玩家获胜，问玩家1是否能获胜。

思路：
参照大神的方法，游戏类的一般用min-max思路，尽量使自己max，使对手min。
用递归的方法，每次使自己max，然后转交给对手，从对手的角度让对手自己max。求玩家1和玩家2的分数差，分数差>=0, 说明玩家1能获胜。

//55ms
    public boolean PredictTheWinner(int[] nums) {
        if(nums == null || nums.length == 0) {
            return false;
        }
        
        return getScore(nums, 0, nums.length-1) >= 0;
    }
    
    int getScore(int[] nums, int l, int r) {
        if(l == r) {
            return nums[l];
        }
        return Math.max(nums[l] - getScore(nums, l+1, r),
                       nums[r] - getScore(nums, l, r-1));
    }

上面的方法涉及到很多重复的计算，所以保存下每次的结果，后面遇到重复的情况直接返回。

//0ms
    public boolean PredictTheWinner(int[] nums) {
        if(nums == null || nums.length == 0) {
            return false;
        }
        
        int n = nums.length;
        
        int[] mem = new int[n*n];
        return getScore(nums, mem, 0, n-1) >= 0;
    }
    
    int getScore(int[] nums, int[] mem, int l, int r) {
        if(l == r) {
            return nums[l];
        }
        int k = l * nums.length + r;
        if(mem[k] > 0) {
            return mem[k];
        }
        
        mem[k] = Math.max(nums[l] - getScore(nums, mem, l+1, r),
                       nums[r] - getScore(nums, mem, l, r-1));
        
        return mem[k];
    }