动态规划常见问题（打家劫舍）

198. 打家劫舍

题目连接：https://leetcode.cn/problems/house-robber/
题目思路：题中说了你只能隔一家来偷，刚开始的时候有两家是你要考虑的要么偷第一家，要么偷第二家，以这个初始状态推导dp数组。
如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。

如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房，（注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点）

然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

class Solution {
    public 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(dp[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

题目连接：https://leetcode.cn/problems/house-robber-ii/
思路：思路和上一题一样，只不过加入了范围，要么不考虑第一个元素，要么不考虑最后一个元素。

class Solution {
    public int rob(int[] nums) {
        if(nums.length==0) return 0;
        if(nums.length==1) return nums[0];
        int chooseStart=robRange(nums,0,nums.length-2);
        int chooseEnd=robRange(nums,1,nums.length-1);
        int res=Math.max(chooseStart,chooseEnd);
        return res;
    }
    int robRange(int[] nums,int start,int end){
        if(start==end) return nums[start];
        int[] dp=new int[nums.length];
        dp[start]=nums[start];
        dp[start+1]=Math.max(dp[start],nums[start+1]);
        for(int i=start+2;i<=end;i++){
            dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[end];
    }
}

337. 打家劫舍 III

题目连接：https://leetcode.cn/problems/house-robber-iii/
思路：后序遍历才可以拿到之前的值进行计算，通过返回值进行下一步规划。注意这里返回一个二维数组，对应偷该位置和不偷该位置获得的最大金钱。
// 不偷：Max(左孩子不偷，左孩子偷) + Max(又孩子不偷，右孩子偷)
res[0]=Math.max(left[0],left[1])+Math.max(right[0],right[1]);
// 偷：左孩子不偷+ 右孩子不偷 + 当前节点偷
res[1]=root.val+left[0]+right[0];

/**
 * 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=traverse(root);
        return Math.max(res[0],res[1]);
    }
    int[] traverse(TreeNode cur){
        int[] res=new int[2];
        if(cur==null){
            return res;
        }
        int[] left=traverse(cur.left);
        int[] right=traverse(cur.right);
        //不抢本节点
       res[0]=Math.max(left[0],left[1])+Math.max(right[0],right[1]);
        //抢本节点
        res[1]=cur.val+left[0]+right[0];
        return res;
    }
}