【力扣】打家劫舍系列

【力扣】打家劫舍系列

Leetcode 0198 打家劫舍

题目描述：Leetcode 0198 打家劫舍

分析

• 本题的考点：动态规划。

• 分析如下：

代码

• C++

class Solution {
public:
    int rob(vector<int> &nums) {

        int n = nums.size();
        vector<int> f(n + 1), g(n + 1);  // 从1开始，表示第1家店
        for (int i = 1; i <= n; i++) {
            f[i] = g[i - 1] + nums[i - 1];
            g[i] = max(g[i - 1], f[i - 1]);
        }
        return max(f[n], g[n]);
    }
};

• Java

class Solution {
    public int rob(int[] nums) {

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

时空复杂度分析

• 时间复杂度：$O(n)$，n为数组长度。

• 空间复杂度：$O(n)$。

Leetcode 0213 打家劫舍 II

题目描述：Leetcode 0213 打家劫舍 II

分析

• 本题的考点：动态规划。

• 分析过程和Leetcode 0198 打家劫舍一模一样，这一题和LC198的不同点在于所有的房屋是一个圈，为了处理这种情况，我们可以分类讨论：

  （1）如果不偷窃不第一家店，则最后一家店可抢可不抢，此时初始化f[1]=0, g[1]=0；（f、g的下标从1开始）

  （2）如果偷窃不第一家店，则最后一家店不可抢，此时初始化f[1]=nums[0], g[1]=INT_MIN；（g[1]是不合法的状态，因为求最大值，所以将其置为最小值）。

• 本质上，此题和LC198的不同点是初始化。

代码

• C++

class Solution {
public:
    int rob(vector<int> &nums) {

        int n = nums.size();
        if (n == 1) return nums[0];

        // f[i]：必选第 i 个店的情况下的最大值；g[i]：必不选第 i 个店的情况下的最大值
        vector<int> f(n + 1), g(n + 1);  // 从1开始，表示第1家店，对应nums[0]
        // 考虑不抢劫第一家店，则最后一家店可抢可不抢
        for (int i = 2; i <= n; i++) {
            f[i] = g[i - 1] + nums[i - 1];
            g[i] = max(f[i - 1], g[i - 1]);
        }
        int res = max(g[n], f[n]);
        // 考虑抢劫第一家店，则最后一家店不可以抢劫
        f[1] = nums[0];
        g[1] = INT_MIN;  // 此时必选nums[0]，但是g[1]表示必不选nums[0]，不合法，因此不能使用该状态更新其他状态
        for (int i = 2; i <= n; i++) {
            f[i] = g[i - 1] + nums[i - 1];
            g[i] = max(f[i - 1], g[i - 1]);
        }
        return max(res, g[n]);
    }
};

• Java

class Solution {
    public int rob(int[] nums) {

        int n = nums.length;
        if (n == 1) return nums[0];

        int[] f = new int[n + 1], g = new int[n + 1];
        Arrays.fill(f, 0); Arrays.fill(g, 0);
        // (1) 考虑不抢劫第一家店，则最后一家店可抢可不抢
        for (int i = 2; i <= n; i++) {
            f[i] = g[i - 1] + nums[i - 1];
            g[i] = Math.max(f[i - 1], g[i - 1]);
        }
        int res = Math.max(f[n], g[n]);
        // (2) 考虑抢劫第一家店，则最后一家店不可以抢劫
        f[1] = nums[0];
        g[1] = Integer.MIN_VALUE;
        for (int i = 2; i <= n; i++) {
            f[i] = g[i - 1] + nums[i - 1];
            g[i] = Math.max(f[i - 1], g[i - 1]);
        }
        return Math.max(res, g[n]);
    }
}

时空复杂度分析

• 时间复杂度：$O(n)$，n为数组长度。

• 空间复杂度：$O(n)$。

Leetcode 0337 打家劫舍 III

题目描述：Leetcode 0337 打家劫舍 III

分析

• 本题的考点：动态规划、树形DP。

• 分析如下：

代码

• C++

class Solution {
public:
    int rob(TreeNode *root) {
        auto f = dfs(root);
        return max(f[0], f[1]);
    }

    vector<int> dfs(TreeNode *u) {
        if (!u) return {0, 0};
        auto x = dfs(u->left), y = dfs(u->right);
        return {max(x[0], x[1]) + max(y[0], y[1]), x[0] + y[0] + u->val};
    }
};

• Java

class Solution {
    public int rob(TreeNode root) {
        int[] f = dfs(root);
        return Math.max(f[0], f[1]);
    }

    private int[] dfs(TreeNode root) {
        if (root == null) return new int[]{0, 0};
        int[] x = dfs(root.left), y = dfs(root.right);
        return new int[]{Math.max(x[0], x[1]) + Math.max(y[0], y[1]), x[0] + y[0] + root.val};
    }
}

时空复杂度分析

• 时间复杂度：$O(n)$，n为树中节点数。

• 空间复杂度：和递归深度有关。