leetcode打家劫舍1,2,3（dp+递归）

leetcode打家劫舍1
题意：给定一个数组，相邻的数字不能相加，其余数字可以任意相加，问在次情况下最大和是多少
思路：理解题意后就能明白这道题的和最大和是个动态增长的过程而且依赖之前求出来的最大和，我们可以用dp来解决。
dp的动态方程为dp[i] = max(dp[i-2]+nums[i],dp[i-1]）

代码如下：

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

继续对代码空间复杂度，因为我们只用到dp[i-2]和dp[i-1]之前的数据用不上了可以用两个临时变量来存储。
优化后代码如下：

  public int rob(int[] num) {
    int prevMax = 0;
    int currMax = 0;
    for (int x : num) {
        int temp = currMax;
        currMax = Math.max(prevMax + x, currMax);
        prevMax = temp;
    }
    return currMax;
}

leetcode打家劫舍2
题意：在1的基础上头和尾也不能相邻了
思路：对于最大和的影响将分成两种情况
1.抢劫了头但不抢劫尾 即0-n-1
2.不抢街头但抢劫了尾 即1-n
对2者维护最大ans即可

代码如下：

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

    }
}

leetcode打家劫舍3
题意：在二叉树类型的房屋中打劫，依旧满足相连接的点不能抢
思路：递归维护每个结点的两种情况
1.有头结点参与+孙子结点的和
2.无头结点参与+儿子结点的和

代码如下：

class Solution {
   public int rob(TreeNode root) {
        if(root==null){
            return 0;
        }
        int lval = rob(root.left);
        int rval = rob(root.right);
        int llval = 0;
        int lrval = 0;
        int rrval = 0;
        int rlval = 0;
        if(root.left!=null){
            llval = rob(root.left.left);
            lrval = rob(root.left.right);
        }
        if(root.right!=null){
            rrval = rob(root.right.right);
            rlval = rob(root.right.left);
        }
        return Math.max(lval+rval,llval+lrval+rrval+rlval+root.val);
    }
}

继续根据这一思路优化

class Solution {
   
    public int rob(TreeNode root){
        int[] res = doRob(root);
        return Math.max(res[0],res[1]);
    }
    public int[] doRob(TreeNode root){
        int[] res = new int[2];
        if(root==null){
            return res;
        }
        int[] left = doRob(root.left);
        int[] right = doRob(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;
    }
}