代码随想录刷题|LeetCode 198.打家劫舍 213.打家劫舍II 337.打家劫舍III

目录

198.打家劫舍

思路

打家劫舍

213.打家劫舍II

思路

打家劫舍II

337.打家劫舍III

思路

1、确定递归函数的参数和返回值

2、确定终止条件

3、确定遍历顺序

4、确定单层递归的逻辑

5、推导dp数组

打家劫舍III

---

198.打家劫舍

题目链接：力扣

思路

        打家劫舍是动态规划的经典题目，考虑题目后会发现：当前房屋偷与不偷取决于 前一个房屋和前两个房屋是否被偷了。当前状态和前面的状态是一种依赖关系

        要求的其实是从头开始偷，偷到当前家最大值是多少

1、确定dp数组含义

        dp[ i ]:考虑下标 i (包括i)以内的房屋，最多可能偷窃的金额为dp[i]

2、确定递推公式

        是否偷当前家有两种情况：

• 如果偷第i个房间，就说明第 i-1 个不能偷，就不用考虑dp[i-1],那么当前能偷盗的最大值为dp[i-2] + nums[i]
• 如果不偷第i个房间，就说明我们是要考虑 i - 1 房，那么当前能偷盗的最大值就是dp[i - 1]   

3、初始化dp数组

        根据递推公式可以看成，需要初始化的有dp[0] 和 dp[1]

        dp[0] = nums[0];
        dp[1] = Math.max(dp[0],dp[1]);

4、遍历方式

        后面的数据由前面得出，所以从前向后进行遍历

打家劫舍

class Solution {
    public int rob(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
 
        // 创建dp[]数组
        // dp[i]代表偷盗到 i 家总金额为dp[i]
        int[] dp = new int[nums.length];
 
        // 初始化dp数组
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0],nums[1]);
 
        // 遍历更新dp数组
        for (int i = 2; i < nums.length; i++) {
            dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
 
 
        return dp[nums.length-1];
    }
}

213.打家劫舍II

题目链接：力扣

思路

        这道题目和上一道题目的区别是，这道题目中的房屋形成了环，这种就会造成头尾这两件房屋是连接的，在上一道题目中，使用递推公式就可以避免偷连续的两家。这里怎么避免头尾两家重复被偷呢，那就是分情况尽心分析

情况一：包含首元素，但是不包含尾元素
情况二：包含尾元素，但是不包含首元素

        这两种情况中，都可以避免首尾同时被偷，这两种情况又是单纯的打家劫舍问题，计算出两个结果再进行比较就可以

打家劫舍II

class Solution {
    public int rob(int[] nums) {
        if (nums.length == 1) {return nums[0];}
        // 情况二，不考虑尾部元素
        int result1 = robRange(nums,0,nums.length-2);
        // 情况三，不考虑头部元素
        int result2 = robRange(nums,1,nums.length-1); 
        return Math.max(result1,result2);
    }
 
    public int robRange(int[] nums, int start, int end){
 
        if (start == end) return nums[start];
 
        // 创建dp数组
        int[] dp = new int[nums.length];
 
        // 初始化dp数组
        dp[start] = nums[start];
        dp[start + 1] = Math.max(nums[start],nums[start+1]);
 
        // 遍历填充dp数组
        for (int i = start + 2; i <= end; i++) {
            dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
 
        return dp[end];
    }    
}

337.打家劫舍III

题目链接：力扣

思路

        这是一道树形dp的入门题目，目前对这种题目还是束手无策，直接根据题解来复盘

        之前的题目都是再一维或者二维数组上进行状态转移，而在二叉树上就是对二叉树上的节点进行状态转移

1、确定递归函数的参数和返回值

要求的是一个节点偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组

int[] robTree(TreeNode root);

这个返回值就是 dp 数组
dp的含义是：下标为0记录不偷该节点所得到的最大金钱，下标为1记偷该节点得到的最大金钱

2、确定终止条件

在遍历遇到空节点的时候，就可以进行返回了

if (root == null) return int[]{0,0};

这也相当于dp数组的初始化

3、确定遍历顺序

首先知道的是使用后序遍历，因为要通过递归函数的返回值来做下一步计算

通过递归左节点，得到左节点偷与不偷的金钱

通过递归右节点，得到右节点偷与不偷的金钱

int[] left = robTree(root.left);  //左节点偷与不偷的情况
int[] right = robTree(root.right); // 右节点偷与不偷的情况

4、确定单层递归的逻辑

针对某个节点来进行分析：

• 如果偷当前节点，那么左右孩子就不能偷，那么 val1 = root.val + left[0] + right[0] (数组的下标0代表不偷当前节点的情况)
• 如果不偷当前节点，那么左右孩子就可以偷，而且应该偷两个中最大的那个，那么 val2 = max( left[0] , left[1] ) + max( right[0] , right [1] );

int val1 = root->val + left[0] + right[0];
// 不偷cur
int val2 = Math.max(left[0], left[1]) + max(right[0], right[1]);
return {val2, val1};

5、推导dp数组

打家劫舍III

class Solution {
    public int rob(TreeNode root) {
        int[] res = robAction(root);
        return Math.max(res[0],res[1]);
    }
 
    int[] robAction(TreeNode root) {
        int[] res = new int[2];
        if (root == null) {
            return res;
        }
 
        int[] left = robAction(root.left);
        int[] right = robAction(root.right);
 
        // 不偷当前节点的情况
        res[0] = Math.max(left[0],left[1]) + Math.max(right[0],right[1]);
        // 偷当前节点的情况
        res[1] = root.val + left[0] + right[0];
 
        return res;
    }
}