代码随想录day48

打架劫舍

思路:
1、定义dp数组
2、确定递推公式
dp[i] = max(dp[i-2] + nums[i],dp[i-1])
3.dp数组初始化
4.打印dp数组

class Solution {
    public int rob(int[] nums) {
        // dp[i] 表示的是遍历到第i个的时候的最大值dp[i]
        // dp[i ] = Math.max(dp[i-2]+nums[i],dp[i-1])
        int[] dp = new int[nums.length + 1];
        if(nums.length == 1){
            return nums[0];
        }else if(nums.length == 2){
            return Math.max(nums[0],nums[1]);
        }
        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];
    }
}

213. 打家劫舍 II

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


    }
    public int robRange(int[] nums,int start,int end){
        if(start == end) return nums[start];  //只有一个的情况

        if(end - start == 1) return Math.max(nums[start],nums[end]);
        // int len = end - start + 1;
        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 + 1;i++){
            dp[i] = Math.max(dp[i-2] + nums[i],dp[i-1]);
        }
        System.out.println(Arrays.toString(dp));
        return dp[end];
    }
}

337. 打家劫舍 III

/**
 * 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) {
        // 树形DP,入门，两个状态，偷还是不偷
        int[] res = robTree(root);
        return Math.max(res[0],res[1]);
    }
    public int[] robTree(TreeNode root){
        if(root == null) return new int[]{0,0};
        int[] leftDp = robTree(root.left);
        int[] rightDp = robTree(root.right);
        
        // 当前这个我偷了
        int val1 = root.val + leftDp[0] + rightDp[0];
        // 当前这个我没偷，我就需要考虑一下偷没偷的存不存在
        int val2 = Math.max(leftDp[1],leftDp[0]) + Math.max(rightDp[1],rightDp[0]);
        return new int[]{val2,val1};
    }
}