动态规划-打家劫舍问题的思考

打家劫舍labuladong

1.原始打家劫舍

自底向上的解法中，对dp[i]的定义

首先我想到的是

• dp[i] 表示 从当抢劫完前0~i个房子的时候能获得的最多的钱
  对打家劫舍系列第一题是可以得到解的，代码如下：

for(int i=0;i<n;i++)
{
    if(i==0) dp[i]=nums[i];
    else if(i==1) dp[i]=max(nums[i-1],nums[i]);
    else{
        dp[i]=max(dp[i-1],dp[i-2]+nums[i]);
    }
}
return dp[n-1];

• 同时，还可以定义为：
  dp[i] 表示 从第i个房子开始抢劫能获得的最多的钱

 int rob(int[] nums) {
    int n = nums.length;
    // dp[i] = x 表示：
    // 从第 i 间房子开始抢劫，最多能抢到的钱为 x
    // base case: dp[n] = 0
    int[] dp = new int[n + 2];
    for (int i = n - 1; i >= 0; i--) {
        dp[i] = Math.max(dp[i + 1], nums[i] + dp[i + 2]);
    }
    return dp[0];
}

当然以上可以对空间复杂度优化到$O(1)$

自顶向下的解法

如果定义dp(n)的返回值是打劫完第n个房子的最多钱数，提交总是超时（就算用memo优化），所以这里定义dp(n)返回的是从第n个房子开始决定抢还是不抢得到的最多钱数

int dp(int n)
//返回值：从第n个房子开始打劫能收到的最多的钱
{
    if (start >= nums.length) {
        return 0;
    }

    int res = Math.max(
            // 不抢，去下家
            dp(nums, start + 1), 
            // 抢，去下下家
            nums[start] + dp(nums, start + 2)
        );
    return res;
}

用递归的时候需要定义归队边界：
当从所有房子后开始打劫，那就是抢不到钱了 return 0

2.环形排列打家劫舍

【环形数组】关于环形数组的处理，比较常见的就是对长度取余
不过在打家劫舍这道题里，我们只需要分情况讨论就可以，不需要用到长度取余

【解题思路】房子是环形排列的，那么存在首位相邻情况的处理，其实只有三种情况：
首尾都不抢
抢首，不抢尾
抢尾，不抢首

最大值就是我们所求的返回值

【采用哪种方法】这里用递归的方法更容易写出代码
因为对于递推法，dp[i]的定义：
（1）抢完前0~i个房子的最大收益（for i=0~n-1）
（2）从第i个房子开始抢的最大收益(for i=n-1~0)

对于递归法int dp(int n)返回的是抢劫完前0~n个房子的最大收益，和递推法（2）一样，但是递归法可以直接按照解题思路写出代码

3.在二叉树上打家劫舍

因为二叉树结构体的定义，从父节点找子节点容易，而从子节点找父节点不方便，所以写状态转移方程的时候，父节点的dp值由子节点dp值推导出来容易写，即自顶向下比较容易

因为是自顶向下，所以用递归比较容易写出代码（当然递推也可以）

int dp(TreeNode root)
return 从root开始决定抢不抢的，直到叶节点，能得到的最多的钱

找root的下下个节点的时候需要注意，如果root！=NULL，那么root一定有左右子树，但是左右子树可能是空；但是root不一定有下下层，因为当root的子节点是空的时候，根本不存在下下层，所以需要单独判断一下root的子节点

int rob(TreeNode root) {
    if (root == null) return 0;
    // 利用备忘录消除重叠子问题
    if (memo.containsKey(root)) 
        return memo.get(root);
    // 抢，然后去下下家
    int do_it = root.val
        + (root.left == null ? 
            0 : rob(root.left.left) + rob(root.left.right))
        + (root.right == null ? 
            0 : rob(root.right.left) + rob(root.right.right));
    // 不抢，然后去下家
    int not_do = rob(root.left) + rob(root.right);

    int res = Math.max(do_it, not_do);
    memo.put(root, res);
    return res;
}

如果dp[i]定义成，从0~i抢劫得到的最大钱数，那么求dp[i]需要知道i的父节点，和父节点的父节点，就不容易表示