打家劫舍I

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

显然这道题考察的是动态规划。由于我们不能同时偷相邻两个房屋的现金，所以要考虑两种情况：

如果偷取第i个房屋的现金，则不能偷取第i-1个房屋的
如果不偷取第i个房屋的现金，则可以偷取第i-1个房屋的

也就是说，如果我们用num[i]来记录第i个房屋里的现金数、用dp[i]来记录前i个房屋可以偷取的最大现金数，则有

i=0时，dp[i]=num[i]
i≠0时，dp[i]=max(dp[i - 2] + nums[i], dp[i - 1])

代码示例如下：

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

打家劫舍II

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

简单来说，相比于第一题，不同之处在于前一题房屋为行排列，这一题为圈排列。还是动态规划。
既然有第一题的存在，为何不利用一下？行排列和圈排列之间可以怎么转换呢？既然相邻两个房屋不能同时取，岂不是意味着可以在圈中任取相邻两个点，将两点分别作为行排列的开头，取两种行排列的最大值。这样就可以把圈排列转换成行排列了。

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

打家劫舍III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

输入样例

输入: [3,4,5,1,3,null,1]
3
/
4 5
/ \ \
1 3 1
输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

在前两道题的基础上，这道题更进了一步，应用到了树的结构。不要看到题目就慌了，其实思路和前面两道题是差不多的。
父、子结点不能同时偷取，这和前面的相邻两个点不能同时偷取同样道理。与前两道题不同的是，我们需要两个数组来记录偷取现金的最大值，考虑是否偷取该结点的现金最大值分别是多少。

p,up分别记录偷取以及不偷取该结点能获得的最大值

如果偷取该结点，则其子节点不能偷取，即
p[node] = node->val + up[node->left] + up[node->right]

如果不偷取该结点，则其子节点可偷可不偷，即
up[node] = max(p[node->left], up[node->left]) + max(p[node->right], up[node->right])

思路很简单，直接上代码

/**
 * 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:
   unordered_map <TreeNode*, int> p, up;//pick,unpick
    int rob(TreeNode* root) {
        dfs(root);
        return max(p[root], up[root]);
    }
    void dfs(TreeNode* node) {
        if (!node)return;
        dfs(node->left);
        dfs(node->right);
        p[node] = node->val + up[node->left] + up[node->right];
        up[node] = max(p[node->left], up[node->left]) + max(p[node->right], up[node->right]);
    }
};

以上就是本人对打家劫舍三道题简单粗暴的思路，仅供参考。
更多大佬解法可以去LeetCode评论区学习学习。