Leetcode刷题笔记题解（C++）:打家劫舍 I & II & III

首先说一下打家劫舍这个问题， 典型的动态规划问题，三个我都写在 一块吧，方便以后查看整理

说一下动态规划的思路步骤：

1.找出重复子问题

2.状态定义，推导动态方程

3.写代码（额，这个不太记得，我的思路差不多这样）

 打家劫舍I

我刚开始拿到这个题的时候，想得挺简单的，就是把下标奇数（1.3.5.7.....）的求和，再把下标偶数（0.2.4.6.8...）的求和，然后取最大值即为结果，

emm，但是 这种情况我就方了： [4,2,3,7] 是不是4+7更大呢。

1.找出子问题 比如啊[4,2,3,7,6] 你要算走到6取最大值，你可以看做[4,2,3]最大值+6与[4,2,3,7]最大值进行比较取最大值

2.得到动态方程用max[i]表示第i个数时的最大值

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

3.写代码咯

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

    int rob(vector<int>& nums) {
        if(nums.empty())  return 0;
        if(nums.size()==1) return nums[0];
        int res;
        int temp1=nums[0];
        int temp2=max(nums[0],nums[1]);
        for(int i=2;i<nums.size();i++){
            res=max(temp2,temp1+nums[i]);
            temp1=temp2;
            temp2=res;
        }
        return temp2;
    }
};

打家劫舍II

在I的基础上把这个房子弄成了一个环，那就是首尾只能取一个

自然就是分为了2种情况，选第一个和不选第一个，然后子问题就细化成了前N-1个数按所需求最大值，后N-1个数按所需求最大值

动态方程可以写为

result=max（选第一个，不选第一个）

代码如下：

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]);
        if(nums.size()==3) return max(max(nums[0],nums[1]),nums[2]);
        int temp1=nums[0];
        int temp2=max(nums[0],nums[1]);
        int temp3=nums[1];
        int temp4=max(nums[1],nums[2]);
        int max1=0;
        int max2=0;
        //选择第一个
        for(int i=2;i<nums.size()-1;i++){
            max1=max(temp1+nums[i],temp2);
            temp1=temp2;
            temp2=max1;
        }//不选择第一个
        for(int i=3;i<nums.size();i++){
            max2=max(temp3+nums[i],temp4);
            temp3=temp4;
            temp4=max2;
        }
        return max(max1,max2);
    }
};

打家劫舍III

 

和上两题不同的是：本题是二叉树形状，树中直接相连（也就是父子节点）不能同时打劫。

  实际上，有上一题的经验，我们不难找到规律：这里可以按根结点是否打劫分为两种情况，如果根结点被打劫，那么意味着它的子节点都不能打劫，需要直接打劫其孙子辈节点；如果根结点不打劫，那么可以考虑其左右孩子。同时，由于树的特性，左右子树都是子问题，因此实际上就是两种情况分别递归。

1.子问题：选择当前节点，或者不选择当前节点

2.动态方程：每个节点两个选择：
（1）偷——两个子结点不能偷，能得到的最多钱存在steal[0]里面
（2）不偷——两个子结点需要比自己偷有更多的钱，存在steal[1]里面
用一个数组steal来存储是否偷窃的钱
那么能偷到的最多钱：
（1）不偷时，=左右子能偷到的钱之和
（2）偷时，=左孩子不偷时的钱+右孩子不偷时的钱+当前节点的钱

class Solution {
    public int rob(TreeNode root) {
        /*
        按根偷不偷，分两种情况，分别递归
        */
        if(root==null)
            return 0;
        int res1=0;
        //根在结果中
        res1+=root.val;
        if(root.left!=null)
            res1+=(rob(root.left.left)+rob(root.left.right));
        if(root.right!=null)
            res1+=(rob(root.right.left)+rob(root.right.right));
        
        //根不在结果中
        int res2=rob(root.left)+rob(root.right);
        return Math.max(res1,res2);
    }
}

 

/**
 * 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) 
    {
        auto ret = dfs(root);
        return max(ret[0], ret[1]);
    }

    vector<int> dfs(TreeNode* root)
    {
        if (!root) return {0 ,0};
        auto ret1 = dfs(root->left);
        auto ret2 = dfs(root->right);
        return {root->val + ret1[1] + ret2[1], max(ret1[0], ret1[1]) + max(ret2[0], ret2[1])};
    }
};