解法1：递归

思路：
在这里插入图片描述

public static void main(String[] args) {
        int[] array=new int[]{5,200,2,3,1}; //模拟石子游戏，堆数为偶，先手必赢
        //int[] array=new int[]{5,200,2,3,1};//堆数为5是奇数 先手必输
        int sum=0;
        for (int i : array) {
            sum+=i;
        }
        //先手 第一个人
        int p1 = maxScore(array, 0, array.length - 1);
        System.out.println(p1);
        //如果第一个人的值》第二个人就返回true
        System.out.println(p1 > sum-p1);
    }

    public static int maxScore(int[] array,int l,int r){
        if (l == r){
            return array[l];
        }

        //左右两边的分数  这里其实并不是求他们的最大值，不是贪心算法
        int leftScore=0,rightScore=0;
        if (r-l == 1){
            leftScore=array[l];
            rightScore=array[r];
        }
        if (r-l > 1){
            //就是第一人选了l 后，那么它只能选第二个可能选的最小的那个
            // （不断地递归求最小的，这里Math.min并不是单纯的最小）
            leftScore=array[l]+Math.min(maxScore(array,l+2,r),maxScore(array,l+1,r-1));
            rightScore=array[r]+Math.min(maxScore(array,l+1,r-1),maxScore(array,l,r-2));
        }
        //每次都会返回的是取左边先还是取右边导致结果最大的那个
        return Math.max(leftScore,rightScore);
    }

递归优化：

由于上面的递归太多，我们可以换一种思路，每次选完之后-另一个对手选的，如果大于0则表示本轮赢了，再不断地递归：

array[l]代表你选了l，array[i]-maxScore1(array,l+1,r)代表得分

 public static void main(String[] args) {
        int[] array=new int[]{5,200,2,3};
        int p1 = maxScore1(array, 0, array.length - 1);
        System.out.println(p1); //输出值为-代表输了多少分 ，正表示赢了多少分
    }
    public static int maxScore1(int[] array,int l,int r){
        if (l ==r){
            return array[l];
        }
        int leftScore=array[l]-maxScore1(array,l+1,r);
        int rightScore=array[r]-maxScore1(array,l,r-1);
        //差值最大 赢面就越大
        return Math.max(leftScore,rightScore);
    }

解法2 动态规划dp

上面的递归升级版还是有点问题，如maxScore1(array,l+1,r)是计算l+1到r的差值，存在大量重复就是leftScore和rightScore只选一个，那一个的递归就浪费了。

这里动态规划的思路：就是把maxScore1(array,l+1,r)类似的差值存储起来，下次用就直接调用就行。这里是把它存到二维数组 [i+1][j] ? [i][j+1] (代表左移和右移)（dp数组）

public static void main(String[] args) {
        int[] array=new int[]{5,200,2,3}；
        System.out.println(dp(array));
    } 
    //动态规划 将上面升级版的差值存到dp数组中
    //dp数组初始化是难点
    public static boolean dp(int[] array){
        int length = array.length;
        int[][] dp=new int[length][length];
        for (int i = 0; i < length; i++) {
            //当i和j相等 那么就直接返回array[i]就行，这里的i相当于上面的l
            dp[i][i]=array[i];
        }
        //i最多到length-2，因为你选了length-2，那么length-1自动给第二名选手了
        for (int i = length-2; i >=0; i--) {
            for (int j = i+1; j < length; j++) {
                dp[i][j]=Math.max(array[i]-dp[i+1][j],array[j]-dp[i][j-1]);
            }
        }
        return dp[0][length-1]>=0;
    }