LeetCode打家劫舍问题

打家劫舍I

简单的DP

设置两个数组 f[i] 代表必偷第i个，g[i]代表不偷第i个

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

打家劫舍II

这里跟第一题最大的区别在于第一家跟第n家不能同时偷

要么偷1不偷n

要么偷n不偷n

要么都不偷

所以分类讨论

第一种

不选第一家--------f[n] 一定选n  G[n]一定不选n

这里包含了 不选0不选n    和  不选0选n

第二种

选择第一家------f[n]代表又选0又选n 直接pass不符合题目要求   G[N]代表不选n ，选0或者不选0不确定

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> g(n+1),f(n+1);
        for(int i=2;i<=n;i++)
        {
            f[i]=g[i-1]+nums[i-1];
            g[i]=max(f[i-1],g[i-1]);
        }
        int res=max(f[n],g[n]);
        f[1]=nums[0];
        g[1]=0;
        for(int i=2;i<=n;i++)
        {
            f[i]=g[i-1]+nums[i-1];
            g[i]=max(f[i-1],g[i-1]);
        }
        res=max(res,g[n]);
        return res;
    }
};

打家劫舍III

此题是树形DP

对于一棵二叉树，如果选择了跟节点，则不能选择两个儿子

如果没有选择根节点  则可以选儿子或者不选儿子

这里用hash表  unordered_map<nodetree* ,unordered_map<int,int> > f;

第一个关键字代表跟，然后是选择偷为0 的最大值，选择不偷1 的最大值

/**
 * 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:
    map<TreeNode* ,map<int,int> > f;//f 0->rob  1->not rob  
    

    int rob(TreeNode* root) {
       dfs(root);
        return max(f[root][0],f[root][1]);
    }
    void dfs(TreeNode* root)
    {
        if(!root)return ;
        dfs(root->left);
        dfs(root->right);
        f[root][0]=root->val+f[root->left][1]+f[root->right][1];
        f[root][1]=max(f[root->left][0],f[root->left][1])+max(f[root->right][0],f[root->right][1]);
    }

};