拿纸牌

问题描述

给定一个整型数组arr，代表数组不同的纸牌，
玩家A和B依次拿走一张纸牌，
规定玩家A先拿，玩家B后拿，
但每次玩家只能拿走最左边或者最右边的纸牌，
玩家A和B都会根据最优方案拿牌，
返回最后获胜者的分数。

三种解决方法

/**
 * @author IT00ZYQ
 * @Date 2021/4/9 12:06
 **/
public class 拿纸牌 {

    /**
     * 暴力法
     * @param arr
     * @return
     */
    public static int way1(int[] arr) {
        int res = 0;
        res = Math.max(first1(0, arr.length - 1, arr), second1(0, arr.length - 1, arr));
        return res;
    }

    /**
     * 先手函数
     * @param l 最左边的位置
     * @param r 最右边的位置
     * @param arr 所有的牌
     * @return 从[l, r]的牌中，以先手的方式拿到的最高的分数
     */
    public static int first1(int l, int r, int[] arr) {
        if (l == r) {
            return arr[l];
        }
        // Max(拿走最左能获取的分数，拿走最右边能获取的分数)
        return Math.max(arr[l] + second1(l+1, r, arr), arr[r] + second1(l, r-1, arr));
    }

    /**
     * 后手函数
     * @param l 最左边的位置
     * @param r 最右边的位置
     * @param arr 所有的牌
     * @return 从[l, r]的牌中，以后手的方式拿到的最高的分数
     */
    public static int second1(int l, int r, int[] arr) {
        // 由于是后手，当只剩一张牌时，先手方或拿走，后手方无法获取分数
        if (l == r) {
            return 0;
        }
        // Min(拿走最左能获取的分数，拿走最右边能获取的分数)
        // 后手方，从先手方的角度看，只能获取到较差的分数
        return Math.min(first1(l+1, r, arr), first1(l, r-1, arr));
    }


    /**
     * 暴力加缓存
     * @param arr
     * @return
     */
    public static int way2(int[] arr) {
        int res = 0;
        int n = arr.length;
        // 缓存也可以利用hashMap，已"l_r"字符串为键值
        // 利用hashMap不需要O(n²)的复杂度
        int[][] f = new int[n][n];
        int[][] g = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                f[i][j] = -1;
                g[i][j] = -1;
            }
        }
        res = Math.max(first2(0, arr.length - 1, arr, f, g), second2(0, arr.length - 1, arr, f, g));
        return res;
    }

    /**
     * 先手函数
     * @param l 最左边的位置
     * @param r 最右边的位置
     * @param arr 所有的牌
     * @return 从[l, r]的牌中，以先手的方式拿到的最高的分数
     */
    public static int first2(int l, int r, int[] arr, int[][] f, int[][] g) {
        if (f[l][r] != -1) {
            return f[l][r];
        }
        if (l == r) {
            return arr[l];
        }
        // Max(拿走最左能获取的分数，拿走最右边能获取的分数)
        int ans = Math.max(arr[l] + second2(l+1, r, arr, f, g), arr[r] + second2(l, r-1, arr, f, g));
        f[l][r] = ans;
        return ans;
    }

    /**
     * 后手函数
     * @param l 最左边的位置
     * @param r 最右边的位置
     * @param arr 所有的牌
     * @return 从[l, r]的牌中，以后手的方式拿到的最高的分数
     */
    public static int second2(int l, int r, int[] arr, int[][] f, int[][] g) {
        if (g[l][r] != -1) {
            return g[l][r];
        }
        // 由于是后手，当只剩一张牌时，先手方或拿走，后手方无法获取分数
        if (l == r) {
            return 0;
        }
        // Min(拿走最左能获取的分数，拿走最右边能获取的分数)
        // 后手方，从先手方的角度看，只能获取到较差的分数
        int ans = Math.min(first2(l+1, r, arr, f, g), first2(l, r-1, arr, f, g));
        g[l][r] = ans;
        return ans;
    }


    /**
     * 动态规划
     * @param arr
     * @return
     */
    public static int way3(int[] arr) {
        int n = arr.length;
        int[][] first = new int[n][n];
        int[][] second = new int[n][n];
        for (int i = 0; i < n; i++) {
            first[i][i] = arr[i];
        }
        // 每一次循环赋值一条对角线
        for (int i = 1; i < n; i++) {
            int col = i;
            int row = 0;
            while (col < n && row < n) {
                first[row][col] = Math.max(arr[row] + second[row+1][col],
                        arr[col] + second[row][col-1]);
                second[row][col] = Math.min(first[row+1][col],
                        first[row][col-1]);
                col ++;
                row ++;
            }

        }
        return Math.max(first[0][n-1], second[0][n-1]);
    }


    public static void main(String[] args) {
        int[] arr = {3, 7, 2, 1};
        int[] arr2 = {7, 4, 16, 15, 1};
        System.out.println(way1(arr2));
        System.out.println(way2(arr2));
        System.out.println(way3(arr2));
    }
}

动态规划法详解