打家劫舍——动态规划

1、打家劫舍

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

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

注意：相邻房屋不能偷

/*思路：动态规划 dp[i]表示到第i间房时，所偷窃的最高金额

动态方程：dp[i] = max(dp[i-2]+nums[i], dp[i-1]) */
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]=nums[0]>nums[1]? nums[0]:nums[1];
　　for(int i=2;i<n;i++){
　　　　dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
　　}
　　return dp[n-1];
}

2、打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

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

注意：相邻房屋不能偷（第一个和最后一个也是相邻的哦）

/*动态规划，方法同1 ，一个偷0-N-2，一个偷1-n-1，比较最大值即可*/

    int rob(vector<int>& nums) {

        int n=nums.size();

        if(n==0){

            return 0;

        }

        if(n==1){

            return nums[0];

        }

        if(n==2){

            return max(nums[0],nums[1]);

        }

        vector<int> dp(n);

        dp[0]=nums[0];

        dp[1]=max(nums[0],nums[1]);

        for(int i=2;i<n-1;i++){

            dp[i]=max(dp[i-1],dp[i-2]+nums[i]);

        } 

        int ans=dp[n-2];

    

        dp[1]=nums[1];

        dp[2]=max(nums[1],nums[2]);

        for(int i=3;i<n;i++){

            dp[i]=max(dp[i-1],dp[i-2]+nums[i]);

        }

        ans=max(ans,dp[n-1]);

        return ans;

    }

3、打家劫舍 III

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

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:

输入: [3,2,3,null,3,null,1]

3
/
2 3
   
  3 1

输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:

输入: [3,4,5,1,3,null,1]

  3
 /
4 5
/
1 3 1

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

 思路：

1、对于一个以 node 为根节点的二叉树而言，如果尝试偷取 node 节点，那么势必不能偷取其左右子节点，然后继续尝试偷取其左右子节点的左右子节点。

2、如果不偷取该节点，那么只能尝试偷取其左右子节点。

3、比较两种方式的结果，谁大取谁。

 

/**

 * 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:

    int rob(TreeNode* root) {

        return tryRob(root);

    }

    int tryRob(TreeNode * node){  //尝试对以node为跟节点的二叉树进行偷取，返回偷取的最大值

        if(!node){

            return 0;

        }

        if(sums.count(node)) {  //判断该节点是否被偷取过

            return sums[node];

        }

        //偷取该节点

        int res1=0;

        if(node->left){

            res1+=( tryRob(node->left->left)+tryRob(node->left->right) );

        }

        if(node->right){

            res1+=( tryRob(node->right->left)+tryRob(node->right->right) );

        }

        res1+=node->val;

 

        //不偷取该节点

        int res2=tryRob(node->left)+tryRob(node->right);

 

        sums[node]=max(res1,res2);

        return sums[node];

    }

private:

    unordered_map<TreeNode *, int>sums;  //用于存放已偷取节点的值

};