代码随想录算法训练营第四十五天 | 198.打家劫舍，213.打家劫舍II，337.打家劫舍III

原创已于 2024-11-07 12:14:37 修改 · 240 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法

于 2024-11-06 11:48:07 首次发布

198. 打家劫舍

题目讲解：代码随想录
重点：

理解递推公式。

思路：

dp数组的含义

// 只取下标前i个房屋能偷窃的最高金额
int[] dp = new int[nums.length];

递推公式

// 不偷下标为i的房屋 和 偷下标为i的房屋 取最大
dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);

dp数组的初始化

// 只取下标0的房屋
dp[0] = nums[0];
// 取下标0和1的房屋
dp[1] = Math.max(nums[0], nums[1]);

遍历顺序

// 先前向后遍历
for (int i = 2; i < nums.length; i++)

模拟dp数组

[2, 7, 11, 11, 12]

public int rob(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    if (nums.length == 1) return nums[0];
    // 只取下标前i个房屋能偷窃的最高金额
    int[] dp = new int[nums.length];
    // 只取下标0的房屋
    dp[0] = nums[0];
    // 取下标0和1的房屋
    dp[1] = Math.max(nums[0], nums[1]);
    // 先前向后遍历
    for (int i = 2; i < nums.length; i++) {
        // 不偷下标为i的房屋 和 偷下标为i的房屋 取最大
        dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
    }
    return dp[nums.length - 1];
}

213. 打家劫舍 II

题目讲解：代码随想录
重点：

理解分析题目的两种情况。

思路：

分析题目
情况一：考虑不包含首尾元素
情况二：考虑包含首元素，不包含尾元素
情况三：考虑包含尾元素，不包含首元素
情况二和情况三都包含了情况一了，所以只考虑情况二和情况三就可以了。
dp数组的含义
// 只取下标start的房屋
dp[start] = nums[start];
递推公式
// 不偷下标为i的房屋 和 偷下标为i的房屋 取最大
dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
dp数组的初始化
// 只取下标start的房屋
dp[start] = nums[start];
// 取下标start和(start+1)的房屋
dp[start + 1] = Math.max(nums[start], nums[start + 1]);
遍历顺序
// 先前向后遍历
for (int i = start + 2; i < end; i++)
模拟dp数组

public int rob(int[] nums) {
    if (nums == null || nums.length == 0) return 0;
    if (nums.length == 1) return nums[0];
    if (nums.length == 2) return Math.max(nums[0], nums[1]);
    // 两种情况
    // 1. 考虑包含首元素，不包含尾元素
    // 2. 考虑包含尾元素，不包含首元素
    return Math.max(robAction(nums, 0, nums.length - 1), robAction(nums, 1, nums.length));
}

private int robAction(int[] nums, int start, int end) {
    if (start == end) return nums[start];
    // 只取下标前i个房屋能偷窃的最高金额
    int[] dp = new int[nums.length];
    // 只取下标start的房屋
    dp[start] = nums[start];
    // 取下标start和(start+1)的房屋
    dp[start + 1] = Math.max(nums[start], nums[start + 1]);
    // 先前向后遍历
    for (int i = start + 2; i < end; i++) {
        // 不偷下标为i的房屋 和 偷下标为i的房屋 取最大
        dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
    }
    return dp[end - 1];
}

337.打家劫舍 III

题目讲解：代码随想录
重点：

理解递归和动态规划的结合。
理解后序遍历，因为通过递归函数的返回值来做下一步计算。

思路：

确定递归函数的参数和返回值
private int[] robAction(TreeNode root)
确定终止条件
if (root == null) return dp;
确定遍历顺序
// 后序遍历: 左右中
int[] left = robAction(root.left);
int[] right = robAction(root.right);
// 中的代码省略
确定单层递归的逻辑
// dp[0]: 不偷当前节点, 那左右子节点偷不偷都可以
dp[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
// dp[1]: 偷当前节点, 左右子节点都不能偷
dp[1] = root.val + left[0] + right[0];
模拟dp数组

public int rob(TreeNode root) {
    // dp[0]不偷当前房屋能获得的最大金额, dp[1]偷当前房屋能获得的最大金额
    int[] dp = robAction(root);
    return Math.max(dp[0], dp[1]);
}

// 递归函数的参数及返回值
private int[] robAction(TreeNode root) {
    int[] dp = new int[2];
    // 终止条件
    if (root == null) return dp;
    // 后序遍历: 左右中
    int[] left = robAction(root.left);
    int[] right = robAction(root.right);
    // dp[0]: 不偷当前节点
    dp[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
    // dp[1]: 偷当前节点
    dp[1] = root.val + left[0] + right[0];
    return dp;
}