Day 48 | 198. House Robber | 213. House Robber II | 337. House Robber III

王锴KKKKKKyle

已于 2023-08-16 23:20:56 修改

阅读量125

点赞数

分类专栏： LeetCode 文章标签： java leetcode 算法

于 2023-07-25 21:14:43 首次发布

本文链接：https://blog.csdn.net/kyle313606922/article/details/131898436

版权

LeetCode 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

198. House Robber

Question Link

class Solution {
    public int rob(int[] nums) {
        if(nums.length==1)
            return nums[0];
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        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];
    }
}

dp[i]: The maximum amount of money that could be robbed from houses whose index is within the i (include i)
Recursion Formula
- If rob the house with index i : dp[i - 2] + nums[i]
- If don’t rob the house with index i : dp[i - 1]
Because the recursion formula is based on dp[0] and dp[1]. We could initialize the dp array as follows.
- According to the definition of dp[i]. The dp[0] must be nums[0].
- dp[1] is the maximum value of nums[0] and nums[1]
Traverse order must be from front to back, cause dp[i] is derived from dp[i - 2] and dp[i - 1]

213. House Robber II

Question Link

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 1)
            return nums[0];
        if(nums.length == 2)
            return Math.max(nums[0], nums[1]);
        
        return Math.max(robAction(nums, 0, nums.length - 2), robAction(nums, 1, nums.length - 1));
    }

     public int robAction(int[] nums, int start, int end) {
        int[] dp = new int[nums.length];
        dp[start] = nums[start];
        dp[start+1] = Math.max(nums[start], nums[start+1]);
        for(int i = start + 2; i <= end; i++){
            dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
        }
        return dp[end];
    }
}

We need to consider two situations:
- Include the first element, not include the tail element
- Include the tail element, not include the first element

337. House Robber III

Question Link

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
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;
    }
}

The length of dp[i] array is 2.
- dp[0] records the maximum amount of money that does not include this node.
- dp[1] records the maximum amount of money that includes this node.
Termination condition: null node
The traversal order must be post order traversal, cause we need the return value of the recursive function to do the next calculation.
If does not rob current node, then rob left and right child nodes
- dp[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1])
If rob current node, then dose not rob left and right child nodes
- dp[1] = root.val + left[0] + right[0]

王锴KKKKKKyle

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day 48 | 198. House Robber | 213. House Robber II | 337. House Robber III

Day 48 | 198. House Robber | 213. House Robber II | 337. House Robber III
复制链接

扫一扫