代码随想录Day48

最新推荐文章于 2024-07-20 09:51:47 发布

二手木乃伊

最新推荐文章于 2024-07-20 09:51:47 发布

阅读量244

点赞数 2

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/qq_45655634/article/details/137525603

版权

本文介绍了三种不同情况下的打家劫舍问题的动态规划解决方案，包括数组（基础）、环形数组和二叉树。作者强调了特殊思路的难点在于理解而非编程，最后提到今天的实践进展不太顺利。

摘要由CSDN通过智能技术生成

Day 48 动态规划part09

今日任务

198.打家劫舍
213.打家劫舍II
337.打家劫舍III

代码实现

基础打家劫舍

class Solution {
    public static int rob(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
		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 - 2] + nums[i], dp[i - 1]);
        }
        return dp[nums.length - 1];
    }
}

环形打家劫舍

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

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

}

二叉树打家劫舍，难想

/**
 * 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[] ints = robAction(root);
        return Math.max(ints[0], ints[1]);
    }

    public int[] robAction(TreeNode root) {
        //dp[0]表示不加本节点的最大值 dp[1]表示加上本节点的最大值
        int[] dp = new int[2];
        if (root == null) return dp;
        int[] left = robAction(root.left);
        int[] right = robAction(root.right);
        //不加本节点，下一个节点加不加都行
        dp[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        dp[1] = root.val + left[0] + right[0];
        return dp;
    }

}