上岸算法 I LeetCode Weekly Contest 219解题报告

No.1 比赛中的配对次数
解题思路

模拟过程即可，较简单。

代码展示

class Solution {

public int numberOfMatches(int n) {

    int res = 0;

    while (n > 1) {

        res += n / 2;

        n = (n + 1) / 2;

    }

    return res;

}

}

No.2十-二进制数的最少数目
解题思路

取决于最大的数字是多少。

代码展示

class Solution {

public int minPartitions(String n) {

    int res = 0;

    for (int i = 0; i < n.length(); i++) {

        res = Math.max(res, n.charAt(i) - '0');

    }

    return res;

}

}

No.3 石子游戏VII
解题思路

区间动态规划问题。

定义状态: dp[i][j] 表示区间 [i, j] 的得分差值

状态转移: 当一个人面临 [i, j] 的情况时，在拿左边和拿右边之间选择自己获得分数更大的情况，详见代码。

定义 prefixSum 表示前缀和以辅助计算。

代码展示

class Solution {

public int stoneGameVII(int[] stones) {

    int n = stones.length;

    int[] prefixSum = new int[n + 1];

    for (int i = 0; i < n; i++) {

        prefixSum[i + 1] = prefixSum[i] + stones[i];

    }

    int[][] dp = new int[n][n];

    for (int i = n - 1; i >= 0; --i) {

        for (int j = i; j < n; ++j) {

            if (i != j) { // 边界: dp[i][i] = 0

                dp[i][j] = Math.max(

                        // 拿了左边的

                        (prefixSum[j + 1] - prefixSum[i + 1]) - dp[i + 1][j],

                        // 拿了右边的

                        (prefixSum[j] - prefixSum[i]) - dp[i][j - 1]

                );

            }

        }

    }

    return dp[0][n - 1];

}

}

No.4 堆叠长方体的最大高度
解题思路

该题目类似嵌套矩形的问题，而嵌套矩形问题又是最长上升子序列的变体，所以本质上和 LIS 问题没有太大区别。

定义状态: dp[i] 表示以 i 结尾的长方体上最高能堆叠多高。

与处理二维一样地，先要对长方体进行排序，然后再递推求解。

注意最终答案是 max{ dp }

代码展示

class Solution {

public int maxHeight(int[][] cuboids) {

    // 排序

    for (int[] c : cuboids) {

        Arrays.sort(c);

    }

    Arrays.sort(cuboids, (a, b) -> {

        if (a[0] != b[0])

            return Integer.compare(a[0], b[0]);

        if (a[1] != b[1])

            return Integer.compare(a[1], b[1]);

        return Integer.compare(a[2], b[2]);

    });

    // dp[i] 表示以第 i 个长方体为末尾时，能堆叠的最大高度

    int[] dp = new int[cuboids.length];

    for (int i = 0; i < cuboids.length; i++) {

        dp[i] = cuboids[i][2];

        for (int j = 0; j < i; j++)

            if (cuboids[j][0] <= cuboids[i][0] &&

                    cuboids[j][1] <= cuboids[i][1] &&

                    cuboids[j][2] <= cuboids[i][2]) {

                dp[i] = Math.max(dp[i], dp[j] + cuboids[i][2]);

            }

    }

    return Arrays.stream(dp).max().getAsInt();

}

}