[1,2,100,8]纸牌游戏，有A、B两个玩家，先手后手都是只能从左边，右边拿。谁分多胜。
    范围上尝试，F(arr,L,R) L~R中拿到最大分数 。

    2.     // 暴力递归
    3.     public static int win1(int[] arr) {
    4.         if (arr == null || arr.length == 0) {
    5.             return 0;
    6.         }
    7.         int first = f1(arr, 0, arr.length - 1);
    8.         int second = g1(arr, 0, arr.length - 1);
    9.         return Math.max(first, second);
    10.     }
    12.     // arr[L..R]，先手获得的最好分数返回，
    13.     public static int f1(int[] arr, int L, int R) {
    14.         if (L == R) {
    15.             return arr[L]; // 一张牌
    16.         }
    17.         int p1 = arr[L] + g1(arr, L + 1, R);
    18.         int p2 = arr[R] + g1(arr, L, R - 1);
    19.         return Math.max(p1, p2);
    20.     }
    22.     // // arr[L..R]，后手获得的最好分数返回
    23.     public static int g1(int[] arr, int L, int R) {
    24.         if (L == R) { // 最后一张牌肯定是先手的
    25.             return 0;
    26.         }
    27.         int p1 = f1(arr, L + 1, R); // 对手拿走了L位置的数
    28.         int p2 = f1(arr, L, R - 1); // 对手拿走了R位置的数
    29.         return Math.min(p1, p2);
    30.     }
    32.     // 记忆化搜索，搞定可变参数组合  
    33.     public static int win2(int[] arr) {
    34.         if (arr == null || arr.length == 0) {
    35.             return 0;
    36.         }
    37.         int N = arr.length;
    38.         //范围函数L不可能大于R,意味着下半区没有用
    39.         int[][] fmap = new int[N][N];
    40.         int[][] gmap = new int[N][N];
    41.         for (int i = 0; i < N; i++) {
    42.             for (int j = 0; j < N; j++) {
    43.                 fmap[i][j] = -1;
    44.                 gmap[i][j] = -1;
    45.             }
    46.         }
    47.         int first = f2(arr, 0, arr.length - 1, fmap, gmap);
    48.         int second = g2(arr, 0, arr.length - 1, fmap, gmap);
    49.         return Math.max(first, second);
    50.     }
    52.     public static int f2(int[] arr, int L, int R, int[][] fmap, int[][] gmap) {
    53.         if (fmap[L][R] != -1) {
    54.             return fmap[L][R];
    55.         }
    56.         int ans = 0;
    57.         if (L == R) {
    58.             ans = arr[L];
    59.         } else {
    60.             int p1 = arr[L] + g2(arr, L + 1, R, fmap, gmap);
    61.             int p2 = arr[R] + g2(arr, L, R - 1, fmap, gmap);
    62.             ans = Math.max(p1, p2);
    63.         }
    64.         fmap[L][R] = ans;
    65.         return ans;
    66.     }
    68.      // arr[L..R]，后手获得的最好分数返回
    69.     public static int g2(int[] arr, int L, int R, int[][] fmap, int[][] gmap) {
    70.         if (gmap[L][R] != -1) {
    71.             return gmap[L][R];
    72.         }
    73.         int ans = 0;
    74.         if (L != R) {
    75.             int p1 = f2(arr, L + 1, R, fmap, gmap); // 对手拿走了L位置的数
    76.             int p2 = f2(arr, L, R - 1, fmap, gmap); // 对手拿走了R位置的数
    77.             ans = Math.min(p1, p2);
    78.         }
    79.         gmap[L][R] = ans;
    80.         return ans;
    81.     }
    82.     // 动态规划
    83.     public static int win3(int[] arr) {
    84.         if (arr == null || arr.length == 0) {
    85.             return 0;
    86.         }
    87.         int N = arr.length;
    88.         int[][] fmap = new int[N][N];
    89.         int[][] gmap = new int[N][N];
    90.         for (int i = 0; i < N; i++) {
    91.             fmap[i][i] = arr[i];
    92.         }
    93.         for (int startCol = 1; startCol < N; startCol++) {
    94.             int L = 0;
    95.             int R = startCol;
    96.             while (R < N) {
    97.                 fmap[L][R] = Math.max(arr[L] + gmap[L + 1][R], arr[R] + gmap[L][R - 1]);
    98.                 gmap[L][R] = Math.min(fmap[L + 1][R], fmap[L][R - 1]);
    99.                 L++;
    100.                 R++;
    101.             }
    102.         }
    103.         return Math.max(fmap[0][N - 1], gmap[0][N - 1]);
    104.     }