代码随想录|动态规划198.打家劫舍 213.打家劫舍II 337.打家劫舍III

198.打家劫舍

题目

参考文章

思路：dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]

dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

这里的dp[i-1]指的是延续上一次偷房间的总金额，不是指偷dp[i-1]的房间。dp[i-2]+nums[i]指的是偷当前房价，因为由题目知道，不能偷相邻的房间，所以要在第i-2的基础上偷

代码：

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(nums[0],nums[1]);

        for(int i=2;i<nums.length;i++){
            dp[i]=Math.max(dp[i-2]+nums[i],dp[i-1]);//这里的dp[i-1]指的是延续上一一次偷房间的总金额，不是指偷dp[i-1]的房间。dp[i-2]+nums[i]指的是偷当前房价，因为由题目知道，不能偷相邻的房间，所以要在第i-2的基础上偷
        }

        return dp[nums.length-1];
    }
}

213.打家劫舍II

题目

参考文章

思路：考虑两种情况，一种是只考虑头元素，一种是只考虑尾元素。还有一种是考虑不包含首尾元素，因为前面说的两种情况都把中间的元素考虑进去了，所以这种情况是可以不用写出来的。这里说的是考虑，不是一定得选择，所以本身不是冲突的。

代码：

class Solution {
    public int rob(int[] nums) {
        if(nums==null||nums.length==0){
            return 0;
        }
        if(nums.length==1){
            return nums[0];
        }
        int len=nums.length;
        return Math.max(robAction(nums,0,len-2),robAction(nums,1,len-1));//因为题目是出现了成环的情况，所以要考虑两种情况，即只考虑首元素，不考虑尾元素；只考虑尾元素，不考虑首元素。即边界问题

    }

     int robAction(int[] nums, int start, int end) {
         if (end == start) return nums[start];//这一步至关重要，因为你传入元素下标时，有两种，而下面情况中用到了下标，而且是start和start+1；以及i-2，i-1；这里如果数组长度过小会出现数组越界（超出长度），所以要首先判断他们下标是否相等
        int[] dp=new int[nums.length];//这部分方法的思路就和198.打家劫舍差不多了

        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-2]+nums[i],dp[i-1]);//然后再根据题意，不能偷相邻的房间即可
        }

        return dp[end];

     }
}

337.打家劫舍III

题目

参考文章

思路：这题是用了二叉树，和上面的两个题目有些不同，他们的相邻指的是节点之间相邻

如果抢了当前节点，两个孩子就不能动，如果没抢当前节点，就可以考虑抢左右孩子

要后序遍历，因为通过递归函数的返回值来做下一步计算

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

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

dp[0] 不偷的最大金钱，dp[1]偷的最大金钱

（left[0],left[1],right[0],right[1]即代表了dp中的dp[0],dp[1]）

这里的left[0],left[1],right[0],right[1]是根据后序遍历得到的值，即是遍历到最后得到的值，然后再一步步往上回溯的过程（回溯过程中，每一个节点的对应偷或不偷都有了一个确定最大金钱）

 不偷当前节点，则找偷或不偷左节点的最大金钱+偷或不偷右节点的最大金钱

 dp[0]=Math.max(left[0],left[1])+Math.max(right[0],right[1]);

  偷当前节点，则不偷其左和右节点

  dp[1]=root.val+left[0]+right[0];

代码：

class Solution {
    public int rob(TreeNode root) {
        int[] dp=robAction(root);
        return Math.max(dp[0],dp[1]);
    }

    int[] robAction(TreeNode root) {
        int[] dp=new int[2];//用于记录偷或不偷的最大金钱
        if(root==null){
            return dp;
        }

        int[] left=robAction(root.left);
        int[] right=robAction(root.right);
        //这里的left[0],left[1],right[0],right[1]是根据后序遍历得到的值，即是遍历到最后得到的值，然后再一步步往上回溯的过程（回溯过程中，每一个节点的对应偷或不偷都有了一个确定最大金钱）
        //不偷当前节点，则找偷或不偷左节点的最大金钱+偷或不偷右节点的最大金钱
        dp[0]=Math.max(left[0],left[1])+Math.max(right[0],right[1]);
        //偷当前节点，则不偷其左和右节点
        dp[1]=root.val+left[0]+right[0];

        return dp;

    }
}