算法整理——【动态规划练习（6）打家劫舍】

本篇博客来整理用动态规划解决打家劫舍系列问题。

一、打家劫舍普通版

题目为198. 打家劫舍 - 力扣（LeetCode），你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

主要思考的方向就是对于每一个房子你是选择偷还是不偷，然后我们使用动态规划对此问题进行计算。动规五部曲如下：

①确定dp数组及其下标含义。dp[i]的意思为考虑了下标i及其之前的房间，能偷到的最大的数。

②递推公式。分为偷i房间和不偷i房间两种。偷i房间时，相邻房间不能偷所以前面这个房间不能考虑，所以为dp[i-2]+nums[i]。如果不偷i的话可以考虑i-1，则为dp[i-1]，dp[i-1]的含义为考虑i-1后能偷到的最大数，不是一定要偷i-1，只是一个考虑范围。总体来看结果为max(dp[i-2]+nums[i],dp[i-1])。

③初始化。dp公式基础为dp[0]和dp[1]，对dp[0]，为只考虑房间0，说明一定要偷房间0，这样才能使最大值，所以dp[0]=nums[0]。对于dp[1]，是考虑到房间1，一定取房间1吗？不一定，取房间0和1中更大的，所以dp[1]=max(nums[0],nums[1])。其他的初始化为0。

④遍历顺序。从递推公式可知，我们需要从前往后遍历，需要先知道前面的再得到后面的。

⑤打印检查dp数组。

完整代码如下：

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        vector<int> dp(nums.size());
        dp[0] = nums[0];
        dp[1] = max(nums[1],nums[0]);
        for(int i = 2; i<nums.size(); i++)
        {
            dp[i] = max(dp[i-1],dp[i-2]+nums[i]);
        }
        return dp[nums.size()-1];
    }
};

二、打家劫舍成环版

题目为213. 打家劫舍 II - 力扣（LeetCode），

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，今晚能够偷窃到的最高金额。

本题在上题的基础上增加了头尾的限制要求，那么我们就在上题的思路上对头尾进行单独考虑。因为头尾最多只能包含一个，所以我们可以分成两种情况计算，包含头不包含尾的和不包含头包含尾的。

完整代码如下：

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0) return 0;
        if(nums.size() == 1) return nums[0];
        if(nums.size() == 2) return max(nums[0],nums[1]);
        int ret = 0;
        vector<int> dp1(nums.size(),0);
        dp1[0] = nums[0];
        dp1[1] = max(nums[0],nums[1]);
        for(int i = 2; i<nums.size()-1; i++)
        {
            dp1[i] = max(dp1[i - 2] + nums[i], dp1[i - 1]);
        }
        ret = dp1[nums.size()-2];
        vector<int> dp2(nums.size(),0);
        dp2[1] = nums[1];
        dp2[2] = max(nums[1],nums[2]);
        for(int i = 3; i<nums.size(); i++)
        {
            dp2[i] = max(dp2[i - 2] + nums[i], dp2[i - 1]);
        }
        ret = max(ret,dp2[nums.size()-1]);
        return ret;
    }
};

三、打家劫舍成树版

题目为337. 打家劫舍 III - 力扣（LeetCode），小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。给定二叉树的 root 。返回在不触动警报的情况下，小偷能够盗取的最高金额 。

这是一个树形dp。对于每个节点我们有两个状态：偷和不偷。dp[0]返回不偷该节点所得到的最大值，dp[1]表示偷该节点所得到的最大值。终止条件为遇到空结点，不管投不投都是0。遍历顺序为后序遍历，因为需要得到左右子树的结果才能计算出当前节点偷/不偷的结果。具体思路可以看代码和注释帮助理解。

具体代码如下，可以结合代码注释理解思路：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int rob(TreeNode* root) {
        //每个节点一个二维数组，分别对应不偷/偷该节点得到的最大值
        vector<int> ret = robTree(root);
        //返回其中更大的
        return max(ret[0],ret[1]);
    }
    vector<int> robTree(TreeNode* cur)
    {
        //终止条件为空结点，返回0
        if(cur == NULL) return vector<int>{0,0};
        //后序遍历 因为需要左右子节点的结果决定根节点不偷/偷的数值
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        //情况1 偷根节点 则不偷左右孩子
        int ret1 = cur->val + left[0] + right[0];
        //情况2 不偷根节点 则可以考虑偷左右孩子，取偷/不偷左右孩子中的最大值
        int ret2 = max(left[0], left[1])+max(right[0],right[1]);
        //返回该节点不偷/偷的值
        return {ret2,ret1};
    }
};

说明：本文为作者整理知识点用于复习巩固，参考了代码随想录的讲解，有问题可以联系作者欢迎讨论~