打家劫舍问题

（一） 简单一维数组

类比 按摩师问题： 其实思想是一样的

问题描述：

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例 1:

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2:

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

分析：

直接下手不好弄， 从小问题入手，
房间为1 打结
房间为2 打劫 max(a[1], a[2])
房间为3 打劫 max(a[1] + a[3], a[2])
房间为n max(a[n] + max a[n-2], max a[n-1])

	因为不能打劫相邻的，所以打劫a[n] 必然不能打劫a[n-1]. 
	因此  想打劫a[n], 前提是打劫范围在 前 a[n-2]家，并获取前a[n-2]家中最大值
	因此，问题逐渐缩小规模到n =2 ， n = 1 逐渐求解
	
   max(a[n] + max a[n-2], max a[n-1])

因此打劫的状态方程为 ：
S(n) = max( a[n] + S(a[n-2]), S(a[n-1]));

我们用同样大的数组S【】更新并保存临时的最大值。

因为循环求解时依赖前两项，所以我们先求出前两项

class Solution {
public:
    int rob(vector<int>& nums) {
       if(nums.size() == 0)
            return 0;
       if(nums.size() == 1)
            return nums[0];

        int len = nums.size();
        int S[len] = {0};
        S[0] = nums[0];
        S[1] = max(nums[0], nums[1]);
        
        for(int i =2; i < len; ++i)
        {
            S[i] = max(nums[i] + S[i-2], S[i-1]);
        }

        return S[len-1];
    }
};

跟最常按摩时间 对比 ，你发现了什么？

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if (n==0) return 0;
        if(n==1) return nums[0];

        vector<int>dp(n);
        dp[0] = nums[0];
        dp[1] = max(nums[0],nums[1]);

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

迭代法： O(1) 复杂度

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if (n==0) return 0;
        if(n==1) return nums[0];

        int  pprev =nums[0];
        int  prev= nums[0]>nums[1] ? nums[0]: nums[1];

        for(int i=2; i<n; ++i)
        {
            int temp = max(prev, pprev + nums[i]);
            pprev =  prev;
            prev = temp;
        }
        return prev;

    }
};

（二）二叉树模型

int rob(TreeNode* root) {
if (root == nullptr) return 0;

int money = root->val;
if (root->left != nullptr) {
    money += (rob(root->left->left) + rob(root->left->right));
}

if (root->right != nullptr) {
    money += (rob(root->right->left) + rob(root->right->right));
}

return max(money, rob(root->left) + rob(root->right));

}

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

/**

• Definition for a binary tree node.
• struct TreeNode {

• int val;
  

• TreeNode *left;
  

• TreeNode *right;
  

• TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  

• };
  */

class Solution {
public:
    unordered_map<TreeNode*,int> mp;
    int dfs(TreeNode* root,int flag)
    {
        if(root==NULL) return 0;
        else
        {
            if(flag==1)//不选它， 那么返回孩子的最大值
                return dfs(root->left,0)+dfs(root->right,0);
            else//选它
            {
                if(mp.find(root)!=mp.end())
                    return max(mp[root],dfs(root->left,0)+dfs(root->right,0));
                    //它的值等于它+ 孩子的选择结果
                int tp=root->val+dfs(root->left,1)+dfs(root->right,1);
                mp[root]=tp;
                //将选择结果存在mp中

                //权衡取大
                return max(mp[root],dfs(root->left,0)+dfs(root->right,0));
            }
        }
    }
    int rob(TreeNode* root) {
        return dfs(root,0);
    }
};