给定一个整型数组arr，代表数值不同的纸牌排成一条线玩家A和玩家B依次拿走每张纸牌

package 左神题目.dp;
//尝试策略 和 状态转移 一码事
//推出暴力递归，什么动态规划或者其他什么东西都是水到渠成
//动态规划：第一步就是写出暴力递归 --> 建立表结构，分析表多大 --> 分析位置怎么依赖
/**给定一个整型数组arr，代表数值不同的纸牌排成一条线玩家A和玩家B依次拿走每张纸牌
 规定玩家A先拿，玩家B后拿
 但是每个玩家每次只能拿走最左或最右的纸牌
 玩家A和玩家B都绝顶聪明
 请返回最后获胜者的分数。*/
public class CardsInLine {
    public static int win1(int[] arr){
        if(arr == null || arr.length == 0){
            return 0;
        }
        //先手
        int first=f1(arr,0,arr.length-1);
        //后手
        int second=g1(arr,0,arr.length-1);
        return Math.max(first,second);
    }

    //arr[L....R],先手获得的最好分数返回
    public static int f1(int[] arr,int L,int R) {
        if(L == R) {
            return arr[L];
        }

        //第一种选择
        int p1 = arr[L] + g1(arr,L+1,R);
        //第二种选择
        int p2 = arr[R] + g1(arr,L,R-1);

        return Math.max(p1,p2);
    }

    //arr[L...R],后手获得的最好分数返回
    public static int g1(int[] arr,int L,int R) {
        if(L == R){
            return 0;
        }

        //第一种最优
        int p1 = f1(arr,L+1,R);//对手拿走了L位置的数
        //第二种最优
        int p2 = f1(arr,L,R-1);//对手拿走了R位置的数

        //为什么返回min,因为做选择的不是你，是你的对手，所以对手会给你返回两个最优里面的最小
        return Math.min(p1,p2);
    }
    //第一次优化：
    //动态规划：第一次优化先用缓存表,然后在纸上画出这两张缓存表，看看每个位置的对应关系，再作出第二次优化
    public static int win2(int[] arr){
        if(arr.length==0||arr == null){
            return 0;
        }
        int N = arr.length;
        //缓存表
        int[][] gmap = new int[N][N];
        int[][] fmap = new int[N][N];
        for(int i = 0;i<N;i++)
            for(int j = 0;j<N;j++)
            {
                gmap[i][j] = -1;
                fmap[i][j] = -1;
            }

        int first = g2(arr,0,N-1,gmap,fmap);
        int second = f2(arr,0,N-1,gmap,fmap);
        return Math.max(first,second);
    }

    public static int f2(int[] arr,int L,int R,int[][] gmap,int[][] fmap){
        //看看是不是第一次,不是直接拿值
        if(fmap[L][R]!=-1){
            return fmap[L][R];
        }
        int ans = 0;
        if(L==R){
            ans = arr[L];
        }else{
            int p1 = arr[L] + g2(arr,L+1,R,gmap,fmap);
            int p2 = arr[R] + g2(arr,L,R-1,gmap,fmap);
            ans = Math.max(p1,p2);
        }
        //加入缓存，最重要的一步
        fmap[L][R] = ans;
        return ans;
    }

    public static int g2(int[] arr,int L,int R,int[][] gmap,int[][] fmap){
        //看看是不是第一次,不是直接拿值
        if(gmap[L][R]!=-1){
            return gmap[L][R];
        }
        int ans = 0;
        if(L != R){
            int p1 = f2(arr,L+1,R,gmap,fmap);
            int p2 = f2(arr,L,R-1,gmap,fmap);
            ans = Math.min(p1,p2);
        }
        //加入缓存，最重要的一步
        gmap[L][R] = ans;
        return ans;
    }

    //第二次优化
    public static int win3(int[] arr){
        if(arr.length==0 || arr==null){
            return 0;
        }
        int N = arr.length;
        //先手表
        int[][] fmap = new int[N][N];
        //后手表
        int[][] gmap = new int[N][N];

        for(int i = 0;i<N;i++){
            fmap[i][i] = arr[i];
        }

        for(int startCol = 1; startCol<N ;startCol++){
            int L = 0;//行
            int R = startCol;//列

            while(R<N){
                fmap[L][R] = Math.max(arr[L]+gmap[L+1][R],arr[R]+gmap[L][R-1]);
                //==> int p1 = arr[L] + g1(arr,L+1,R);
                //    int p2 = arr[R] + g1(arr,L,R-1);
                //    return Math.max(p1,p2);

                gmap[L][R] = Math.min(fmap[L+1][R],fmap[L][R-1]);
                //==> int p1 = f1(arr,L+1,R);
                //    int p2 = f1(arr,L,R-1);
                //    return Math.min(p1,p2);
                R++;
                L++;
            }
        }
        return Math.max(fmap[0][N-1],gmap[0][N-1]);
        //==>  int first = g2(arr,0,N-1,gmap,fmap);
        //     int second = f2(arr,0,N-1,gmap,fmap);
        //     return Math.max(first,second);
    }
    public static void main(String[] args) {
        int[] arr = {50,100,40,10,10,1011,1,1,1,1,11,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,};

        long start1 = System.currentTimeMillis();//计算时间
        System.out.println(win1(arr));
        long end1 = System.currentTimeMillis();
        System.out.println("cost time:" + (end1-start1)+"ms");

        long start2 = System.currentTimeMillis();//计算时间
        System.out.println(win2(arr));
        long end2 = System.currentTimeMillis();
        System.out.println("cost time:" + (end2-start2)+"ms");

        long start3 = System.currentTimeMillis();//计算时间
        System.out.println(win3(arr));
        long end3 = System.currentTimeMillis();
        System.out.println("cost time:" + (end3-start3)+"ms");
    }
}