LeetCode周赛 20201213 题解

5627 石子游戏VII

石子游戏中，爱丽丝和鲍勃轮流进行自己的回合，爱丽丝先开始 。
有 n 块石子排成一排。每个玩家的回合中，可以从行中 移除 最左边的石头或最右边的石头，并获得与该行中剩余石头值之 和 相等的得分。当没有石头可移除时，得分较高者获胜。
鲍勃发现他总是输掉游戏（可怜的鲍勃，他总是输），所以他决定尽力 减小得分的差值 。爱丽丝的目标是最大限度地 扩大得分的差值 。
给你一个整数数组 stones ，其中 stones[i] 表示 从左边开始 的第 i 个石头的值，如果爱丽丝和鲍勃都 发挥出最佳水平 ，请返回他们 得分的差值 。
示例 1：
输入：stones = [5,3,1,4,2]
输出：6
解释：
- 爱丽丝移除 2 ，得分 5 + 3 + 1 + 4 = 13 。游戏情况：爱丽丝 = 13 ，鲍勃 = 0 ，石子 = [5,3,1,4] 。
- 鲍勃移除 5 ，得分 3 + 1 + 4 = 8 。游戏情况：爱丽丝 = 13 ，鲍勃 = 8 ，石子 = [3,1,4] 。
- 爱丽丝移除 3 ，得分 1 + 4 = 5 。游戏情况：爱丽丝 = 18 ，鲍勃 = 8 ，石子 = [1,4] 。
- 鲍勃移除 1 ，得分 4 。游戏情况：爱丽丝 = 18 ，鲍勃 = 12 ，石子 = [4] 。
- 爱丽丝移除 4 ，得分 0 。游戏情况：爱丽丝 = 18 ，鲍勃 = 12 ，石子 = [] 。

得分的差值 18 - 12 = 6 。
示例 2：
输入：stones = [7,90,5,1,100,10,10,2]
输出：122

提示：
n == stones.length
2 <= n <= 1000
1 <= stones[i] <= 1000
相似题目：486

思路：博弈论-动态规划

1. 首先明确——谁是先手谁的得分就最大，题目中说了，鲍勃必输，因为是爱丽丝先开始；所以鲍勃说的尽力 减小得分的差值 也是指减小最终的得分的差值，而不是过程中的
2. dp[i][j]定义为区间[i,j]中我们要的结果（最大差值），在区间[i, j]，dp[i][j] = 先手的总分 - 后手的总分

• 如果dp[i][j]这个区间当前是鲍勃操作，那么鲍勃的得分一定最大。
• 如果选择去掉stones[i]（左边的石块）后当前的分数为sum(stones[i + 1], stones[j])
• 那么区间[i + 1, j]鲍勃的得分是多少呢？不用管它，dp[i + 1][j]一定为对手爱丽丝作为先手得到的结果，因为谁先手谁的得分最大，所以dp[i + 1][j] = 爱丽丝得分 - 鲍勃的得分。

 sum(stones[i + 1], stones[j]) - dp[i + 1][j]
= 鲍勃当前操作得分 - （爱丽丝的总分 - 鲍勃的总分）
= 鲍勃当前操作得分 + 鲍勃的总分 - 爱丽丝的总分
= 鲍勃新的总分 - 爱丽丝的总分 > 0（谁先手谁最大）。

3. 如果去掉stones[j]则原理同上.
   如果当前dp[i][j]是爱丽丝，则将上面的叙述中爱丽丝和鲍勃名字互换。
4. 对于爱丽丝我们很好理解为什么要最大化

dp[i][j] = max(sum(stones[i + 1], stones[j]) - dp[i + 1][j], sum(stones[i], stones[j - 1]) - dp[i][j - 1]);

那么鲍勃为什么也要最大化dp[i][j]呢，因为爱丽丝先手，鲍勃必输，题目给出了。所以只有当鲍勃操作时dp[i][j]最大，才能让爱丽丝操作时得到的结果最小,满足鲍勃的野心。即

爱丽丝当前操作得分 - (鲍勃的总分 - 爱丽丝的总分)【鲍勃操作时的最大化差值dp[i][j]】

基础情况为只有2个石块，值最大的那堆为答案，所以从只有2个石块开始往上进行状态转移。

class Solution {
    public int stoneGameVII(int[] stones) {
        if(stones == null || stones.length == 0){
            return 0;
        }
        int n = stones.length;
        int[][] dp = new int[n][n];
        int[] sum = new int[n+1];//前缀和（int数组默认值为0）,sum[i+1]代表[0,i]的石块，不包括包括i+1
        //如果用sum[i]表示[0,i]的和，那么[i,j-1]的和就是sum[j-1]-sum[i-1],在索引sum[i-1]时，当i=0时就会出界
        for(int i=0; i<n; i++){
            sum[i+1] = sum[i]+stones[i];
        }

        //动态转移方程：可以看出i依赖于i+1，j依赖于j-1.所以i需要从大到小，j需要从小到大
        //dp[i][j] = max(sum(stones[i + 1], stones[j]) - dp[i + 1][j], sum(stones[i], stones[j - 1]) - dp[i][j - 1]);
        for(int i = n-2; i>=0; i--){
            for(int j = i+1; j<n; j++){
                dp[i][j] = Math.max((sum[j+1] - sum[i+1] - dp[i + 1][j]),( sum[j] - sum[i] - dp[i][j - 1]));
            }
        }
        return dp[0][n-1];
    }
}

5245 堆叠长方体的最大高度

最长上升子序列问题 (这个链接写的不好，但是题目值得借鉴：300、435、646、452、673、491)，美团、华为都考过，现在字节也有了

给你 n 个长方体 cuboids ，其中第 i 个长方体的长宽高表示为 cuboids[i] = [widthi, lengthi, heighti]（下标从 0 开始）。请你从 cuboids 选出一个 子集 ，并将它们堆叠起来。
如果 widthi <= widthj 且 lengthi <= lengthj 且 heighti <= heightj ，你就可以将长方体 i 堆叠在长方体 j 上。你可以通过旋转把长方体的长宽高重新排列，以将它放在另一个长方体上。
返回 堆叠长方体 cuboids 可以得到的 最大高度 。
示例 1：
输入：cuboids = [[50,45,20],[95,37,53],[45,23,12]]
输出：190
解释：
第 1 个长方体放在底部，53x37 的一面朝下，高度为 95 。
第 0 个长方体放在中间，45x20 的一面朝下，高度为 50 。
第 2 个长方体放在上面，23x12 的一面朝下，高度为 45 。
总高度是 95 + 50 + 45 = 190 。

示例 2：
输入：cuboids = [[38,25,45],[76,35,3]]
输出：76
解释：
无法将任何长方体放在另一个上面。
选择第 1 个长方体然后旋转它，使 35x3 的一面朝下，其高度为 76 。

示例 3：
输入：cuboids = [[7,11,17],[7,17,11],[11,7,17],[11,17,7],[17,7,11],[17,11,7]]
输出：102
解释：
重新排列长方体后，可以看到所有长方体的尺寸都相同。
你可以把 11x7 的一面朝下，这样它们的高度就是 17 。
堆叠长方体的最大高度为 6 * 17 = 102 。

提示：
n == cuboids.length
1 <= n <= 100
1 <= widthi, lengthi, heighti <= 100

这道题本质上还是最长上升子序列问题，我们不需要关心各个长方体哪个是原来的长宽高，只需要保证按照顺序排列长方体的边长，即（w,l,h）→（w’,l’,h’）其中w’<=l’<=h’,按照题意，为了保证总高度最高，需要将最长的边作为高，那么只有当一个长方体的最短的边长、第二长的边长都比另外一个长方体更短，才可以把它叠放在另一个长方体上。
如果我们将数组进行排序，令数组dp[i]表示以第i个长方体为底的【堆叠长方体】的最大高度，就可以把这个问题转化为最长上升子序列问题了。
为了计算【以第i个长方体为底】的【堆叠长方体】的最大高度和，我们需要找出可以放在第i个长方体上方的所有不同组合的【堆叠长方体】，用这些不同的【堆叠长方体】的高度的最大值，加上最下方的第i个长方体的高度，就是我们需要的dp[i]。
转移方程为：

dp[i] = Max(dp[j]) + cuboids[i][2]; 

其中Max(dp[j])表示所有可以放在第i个长方体上方的所有不同的【堆叠长方体】的高度的【最大值】，cuboids[i][2]表示第i个长方体的高度。

public int maxHeight(int[][] cuboids) {
        // 首先，将各个长方体数组内部的元素（即边长）从小到大进行排序
        for (int[] cuboid : cuboids) {
            Arrays.sort(cuboid);
        }
        // 随后将整个长方体数组按照最短边长、次长边长、最长边长进行排序
        Arrays.sort(cuboids, (o1, o2) -> {
            if (o1[0] != o2[0]) {
                return Integer.compare(o1[0], o2[0]);
            } else if (o1[1] != o2[1]) {
                return Integer.compare(o1[1], o2[1]);
            } else {
                return Integer.compare(o1[2], o2[2]);
            }
        });
        // dp[i]表示【以第i个长方体为底】的【堆叠长方体】的最大高度
        int[] dp = new int[cuboids.length];
        int maxAns = 0;
        // 显然，我们需要找出可以放在第i个长方体上方的所有【堆叠长方体】的最大高度
        // 加上第i个长方体的高度，就可以得出【以第i个长方体为底】的【堆叠长方体】的最大高度
        for (int i = 0; i < cuboids.length; i++) {
            for (int j = 0; j < i; j++) {
                // 虽然我们已经做了排序，但是还不能保证前面的长方体一定能够放在后面的长方体上方，只能保证后面的长方体一定不能放在前面的长方体上
                // 因此需要依次进行判断前面各个【堆叠长方体】能不能放置在第i个长方体上方，并找出前面各个【堆叠长方体】的最大高度的【最大值】
                if (cuboids[j][1] <= cuboids[i][1] && cuboids[j][2] <= cuboids[i][2]) {
                    dp[i] = Math.max(dp[i], dp[j]);
                }
            }
            dp[i] += cuboids[i][2];
            // 更新所有【堆叠长方体】的最大高度
            maxAns = Math.max(maxAns, dp[i]);
        }
        return maxAns;
    }