LeetCode经典算法题：预测赢家+香槟塔java解法

LeetCode经典算法题：预测赢家+香槟塔java解法

1 预测赢家

题目描述

给定一个表示分数的非负整数数组。 玩家 1 从数组任意一端拿取一个分数，随后玩家 2 继续从剩余数组任意一端拿取分数，然后玩家 1 拿，…… 。
每次一个玩家只能拿取一个分数，分数被拿取之后不再可取。直到没有剩余分数可取时游戏结束。最终获得分数总和最多的玩家获胜。

解题思路与代码

给定一个表示分数的数组，预测玩家1是否会成为赢家。可以假设每个玩家的玩法都会使他的分数最大化。

两个值的时候必然是取较大的，三个值，取一个能使自己分数和最大的，后手必然留较小的给先手，因此先手选一个值加上该较小值最大化

 static int maxScore(int[] nums, int l, int r) {
        //剩下一个值，只能取该值
        if (l == r) {
            return nums[l];
        }
        int selectLeft =0, selectRight=nums.length-1;
        //剩下大于两个值，先手选一边(使自己得分最高的一边)，后手则选使对手得分最低的一边
        if ((r - l) >= 2) {
            selectLeft = nums[l] +Math.min(maxScore(nums, l+2, r),maxScore(nums,
                    l+1, r-1));
            selectRight = nums[r] +Math.min(maxScore(nums, l+1, r-1),maxScore(nums,
                    l, r-2));
        }
        //剩下两个值，取较大的
        if ((r - l) == 1) {
            selectLeft = nums[l];
            selectRight = nums[r];
        }
        return Math.max(selectLeft, selectRight);
    }
    int getScore(int[] nums, int start, int end) {
        int selectLeft, selectRight;
        int gap = end - start;
        if (gap == 0) {
            return nums[start];
        } else if (gap == 1) { // 此时直接取左右的值就可以
            selectLeft = nums[start];
            selectRight = nums[end];
        } else if (gap >= 2) { // 如果gap大于2，递归计算selectLeft和selectRight
            // 计算的过程为什么用min，因为要按照对手也是最聪明的来计算。
            int num = getScore(nums, start + 1, end - 1);
            selectLeft = nums[start] + min(getScore(nums, start + 2, end), num);
            selectRight = nums[end] + min(num, getScore(nums, start, end - 2));
        }
        return max(selectLeft, selectRight);
    }
    bool PredictTheWinner(int[] nums) {
        int sum = 0;
        for (int i : nums) {
            sum += i;
            int player1 = getScore(nums, 0, nums.size() - 1);
            int player2 = sum - player1;
            // 如果最终两个玩家的分数相等，那么玩家 1 仍为赢家，所以是大于等于。
            return player1 >= player2;
            //return getScore(nums, 0, nums.size() - 1) >=0 ;
        }
        //差值
        int getScore(int[] nums, int start, int end) {
            if (end == start) {
                return nums[start];
            }
            int selectLeft = nums[start] - getScore(nums, start + 1, end);
            int selectRight = nums[end] - getScore(nums, start, end - 1);
            return max(selectLeft, selectRight);
        }      

动态规划：使用二维数组存储差值

    public boolean PredictTheWinner(int[] nums) {
        int length = nums.length;
        int[][] dp = new int[length][length];
        for (int i = 0; i < length; i++) {
            dp[i][i] = nums[i];
        }
        for (int i = length - 2; i >= 0; i--) {
            for (int j = i + 1; j < length; j++) {
                //j = i +1 因此可以优化为一维数组,下标位置相同才有值，据此推导其他的值
                //Math.max(nums[i] - dp[j][j], nums[j] - dp[j - 1][j - 1]);
                dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]);
            }
        }
        return dp[0][length - 1] >= 0;
    }

2 香槟塔

题目描述

我们把玻璃杯摆成金字塔的形状，其中第一层有1个玻璃杯，第二层有2个，依次类推到第100层，每个玻璃杯(250ml)将盛有香槟。

从顶层的第一个玻璃杯开始倾倒一些香槟，当顶层的杯子满了，任何溢出的香槟都会立刻等流量的流向左右两侧的玻璃杯。当左右两边的杯子也满了，就会等流量的流向它们左右两边的杯子，依次类推。（当最底层的玻璃杯满了，香槟会流到地板上）

例如，在倾倒一杯香槟后，最顶层的玻璃杯满了。倾倒了两杯香槟后，第二层的两个玻璃杯各自盛放一半的香槟。在倒三杯香槟后，第二层的香槟满了 - 此时总共有三个满的玻璃杯。在倒第四杯后，第三层中间的玻璃杯盛放了一半的香槟，他两边的玻璃杯各自盛放了四分之一的香槟现在当倾倒了非负整数杯香槟后，返回第 i 行 j 个玻璃杯所盛放的香槟占玻璃杯容积的比例（i 和 j都从0开始）。

解题思路与代码

    public double champagneTower(int poured, int query_row, int query_glass) {
        double[][] A = new double[102][102];
        A[0][0] = (double) poured;
        for (int r = 0; r <= query_row; ++r) {
            for (int c = 0; c <= r; ++c) {
                double q = (A[r][c] - 1.0) / 2.0;
                if (q > 0) {
                    A[r+1][c] += q;
                    A[r+1][c+1] += q;
                }
            }
        }
        return Math.min(1, A[query_row][query_glass]);
    } 
][c+1] += q;
                }
            }
        }
        return Math.min(1, A[query_row][query_glass]);
    } 

打家劫舍

题目描述

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

输入：[1,2,3,1] 输出：4

输入：[2,7,9,3,1] 输出：12

解题思路与代码

    static int maxMoney(int[] nums,int index){
        if (nums == null || index < 0) {
            return 0;
        }
        if (index == 0) {
            return nums[0];
        }
        return Math.max(maxMoney(nums,index - 2) + nums[index], maxMoney(nums,index
                - 1));
    }
    static int maxMoney(int[] nums){
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int length = nums.length;
        if (length == 1) {
            return nums[0];
        }


        /*
        int[] dp = new int[length];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < length; i++) {
            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[length - 1];
        */

        int first = nums[0], second = Math.max(nums[0], nums[1]);
        for (int i = 2; i < length; i++) {
            int temp = second;
            second = Math.max(first + nums[i], second);
            first = temp;
        }
        return second;
    }

如果房子首尾相连：

    public int rob(int[] nums) {
        int length = nums.length;
        if (length == 1) {
            return nums[0];
        } else if (length == 2) {
            return Math.max(nums[0], nums[1]);
        }
        return Math.max(robRange(nums, 0, length - 2), robRange(nums, 1, length -
                1));
    }
    public int robRange(int[] nums, int start, int end) {
        int first = nums[start], second = Math.max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; i++) {
            int temp = second;
            second = Math.max(first + nums[i], second);
            first = temp;
        }
        return second;
    }

    public int rob(TreeNode root) {
        int[] rootStatus = dfs(root);
        return Math.max(rootStatus[0], rootStatus[1]);
    }
    public int[] dfs(TreeNode node) {
        if (node == null) {
            return new int[]{0, 0};
        }
        int[] l = dfs(node.left);
        int[] r = dfs(node.right);
        int selected = node.val + l[1] + r[1];
        int notSelected = Math.max(l[0], l[1]) + Math.max(r[0], r[1]);
        return new int[]{selected, notSelected};
    }