LeetCode刷题笔记_375. 猜数字大小 II

题目描述

我们正在玩一个猜数游戏，游戏规则如下：

我从 1 到 n 之间选择一个数字。
你来猜我选了哪个数字。
如果你猜到正确的数字，就会 赢得游戏 。
如果你猜错了，那么我会告诉你，我选的数字比你的 更大或者更小 ，并且你需要继续猜数。
每当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。如果你花光了钱，就会 输掉游戏 。
给你一个特定的数字 n ，返回能够 确保你获胜 的最小现金数，不管我选择那个数字 。

输入：n = 10
输出：16

思路

这是一个局部最小，全局最大的问题。
使用动态规划求解。
状态转移方程如下：（非常重要！！！）

class Solution {
    public int getMoneyAmount(int n) {
        int[][] arr = new int[n+1][n+1];
        for(int i = n - 1; i >= 1; i--) {
            for (int j = i + 1; j <= n; j++) {
                int minCost = Integer.MAX_VALUE;
                for (int k = i; k < j; k++) {
                    int cost = k + Math.max(arr[i][k-1], arr[k+1][j]);
                    minCost = Math.min(cost, minCost);
                }
                arr[i][j] = minCost;
            }
        }

        return arr[1][n];
    }
}

需要注意的是，这里的 i 需要从n - 1开始遍历，而不能从 1 开始遍历，因为 k > i，在第三层循环中间，k + 1 > i，因此必须先计算出大的 i 对应的数组值，否则答案会不正确。

时间复杂度：O(N^3)
空间复杂度：O(N^2)

题解

记忆化搜索

使用了递归的方法。

class Solution {
    static int N = 210;
    static int[][] cache = new int[N][N];
    public int getMoneyAmount(int n) {
        return dfs(1, n);
    }
    int dfs(int l, int r) {
        if (l >= r) return 0;
        if (cache[l][r] != 0) return cache[l][r];
        int ans = 0x3f3f3f3f;
        for (int x = l; x <= r; x++) {
            // 当选择的数位 x 时，至少需要 cur 才能猜中数字
            int cur = Math.max(dfs(l, x - 1), dfs(x + 1, r)) + x;
            // 在所有我们可以决策的数值之间取最优
            ans = Math.min(ans, cur);
        }
        cache[l][r] = ans;
        return ans;
    }
}

与动态规划方法有相似的地方，但更容易理解。

打表

class Solution {
    static int N = 200;
    static int[][] f = new int[N + 10][N + 10];
    static {
        for (int len = 2; len <= N; len++) {
            for (int l = 1; l + len - 1 <= N; l++) {
                int r = l + len - 1;
                f[l][r] = 0x3f3f3f3f;
                for (int x = l; x <= r; x++) {
                    int cur = Math.max(f[l][x - 1], f[x + 1][r]) + x;
                    f[l][r] = Math.min(f[l][r], cur);
                }
            }
        }
    }
    public int getMoneyAmount(int n) {
        return f[1][n];
    }
}

这里使用静态代码块首先将表做了出来。

注意这里的0x3f3f3f3f通常用来表示一个无穷大的数字。

其实把他改一下，就是下面这样子。

class Solution {
    public int getMoneyAmount(int n) {
        int[][] arr = new int[n+1][n+1];
        for(int i = 2; i <= n; i++) {
            for (int j = 1; j <= n - i + 1; j++) {
                int r = j + i -1;
                arr[j][r] = 0x3f3f3f3f;
                for (int k = j; k < r; k++) {
                    int cost = k + Math.max(arr[j][k-1], arr[k+1][r]);
                    arr[j][r] = Math.min(cost, arr[j][r]);
                }
             
            }
        }

        return arr[1][n];
    }
}

是不是很像动态规划呢？而且 i 是从小向大遍历了，只不过它的意思从左边界变成了长度。j 表示左边界，r 表示右边界了。

参考资料