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.

方法一：（动态规划+递归）
解析：
dp[i][j]表示第一个人在第i到j个元素之间取到的和最大值；dp[i+1][j]表示第二个人第i+1到j个元素之间取到的和最大值；dp[i][j-1]表示第二个人第i到j-1个元素之间取到的和最大值；
sum[i][j]表示第i个元素和第j个元素之间的数据的和。
状态转移方程：
令lef=nums[i]+sum[i+1][j]-dp[i+1][j];rig=nums[j]+sum[i][j-1]-dp[i][j-1];
dp[i][j]=Math.max(
lef,rig
);
public class Solution {
    public boolean PredictTheWinner(int[] nums) {
        if(nums.length==1)
        {
            return true;
        }
       int[] sum=new int[nums.length];
        sum[0]=nums[0];
       
        for(int i=1;i<nums.length;i++)
        {
            sum[i]=sum[i-1]+nums[i];
        }
        
       int res=dp(nums,sum,0,nums.length-1);
      
        // System.out.println(res);
        if(res>=sum[nums.length-1]-res)
        return true;
        
        return false;
    }
    
    static int dp(int[] nums,int[] sum,int m,int n)
	{
		if(m==n)
			return nums[m];
		int lef=nums[m]+sum[n]-sum[m]-dp(nums,sum,m+1,n);
                int rig=nums[n]+sum[n-1]-sum[m]+nums[m]-dp(nums,sum,m,n-1);
        
		return Math.max(lef,rig);
	}
}