LeetCode198/213/337 打家劫舍I/II/III

原题目

第一题

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber

第二题

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例 1:
输入: [2,3,2]
输出: 3
解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例 2:
输入: [1,2,3,1]
输出: 4
解释: 你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
偷窃到的最高金额 = 1 + 3 = 4 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber-ii

第三题

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber-iii

题目分析

第一题

方法一：
从第一个房子开始，判断偷当前房子的最大金额是多少，根据规则偷了当前房子，就只能偷前面第二个房子，和前面第三个房子，再前面的房子不用管，包含在第三第二个房子的最大金额中，当前的最大金额是当前房子金额加上前第二和第三最大金额的之一。返回最大金额的房子

方法二：记忆化搜索

方法三：一维数组动态规划
状态转移方程：dp[i]=fmax(dp[i-2]+nums[i],dp[i-1])

方法四：常数级动态规划cur=fmax(pre+nums[i],cur)

第二题

在第一题的基础上：第一个和最后一个不能同时抢。 所以：要么不抢第一个，要么不抢最后一个。 注意，不抢第一个的时候，最后一个可抢可不抢；另一种情况同理 取两种情况中的最大值
方法一：
递归超时
方法二：
记忆化搜索
方法三：
动态规划一维空间
方法四：
动态规划常数级空间

第二题

动态规划
方法一（在原数组上更改）：从叶子节点开始向根节点遍历（后序遍历），每次比较当前节点下一行之和和当前节点+下下行之和，将当前节点当做dp存储两者最大之和。
方法二：（常数级空间）同方法一

完整代码

方法一：

int rob(int* nums, int numsSize){
    int max_money=0;
    for(int i=0;i<numsSize;i++)
    {
        if(i==2)
            nums[i]+=nums[i-2];
        else if(i>2)
        nums[i]+=fmax(nums[i-2],nums[i-3]);
        max_money=fmax(max_money,nums[i]);
    }
    return max_money;
}

方法二：

int robs(int *nums,int i,int *memo)
{
    if(i<0)
        return 0;
    else if(i==0)
        return nums[i];
    else if(i==1)
        return fmax(nums[i],nums[i-1]);
    else if(memo[i]>-1)
        return memo[i];
    memo[i]=fmax(robs(nums,i-2,memo)+nums[i],robs(nums,i-1,memo));
    return memo[i];
}

int rob(int* nums, int numsSize){
    int *memo=(int *)malloc(sizeof(int)*numsSize);
    memset(memo,-1,sizeof(int)*numsSize);
    return robs(nums,numsSize-1,memo);
}

方法三：

int rob(int* nums, int numsSize){
    if(numsSize==0)return 0;
    int *dp=(int *)malloc(sizeof(int)*numsSize);
    for(int i=0;i<numsSize;i++)
    {
        if(i==0)
            dp[i]=nums[i];
        else if(i==1)
            dp[i]=fmax(dp[i-1],nums[i]);
        else
        dp[i]=fmax(dp[i-2]+nums[i],dp[i-1]);
    }
    return dp[numsSize-1];
}

改进化简

int rob(int* nums, int numsSize){
    if(numsSize==1)return nums[0];
    int *dp=(int *)malloc(sizeof(int)*(numsSize+2));
    memset(dp,0,sizeof(int)*(numsSize+2));
    for(int i=2;i<numsSize+2;i++)
    {
        dp[i]=fmax(dp[i-1],dp[i-2]+nums[i-2]);
    }
    return dp[numsSize+1];
}

方法四

int rob(int* nums, int numsSize){
    int cur_max=0;//dp[-1]=0;
    int pre_max=0;//dp[-2]=0;
    for(int i=0;i<numsSize;i++)
    {
        int temp=cur_max;//保存dp[i-1];
        cur_max=fmax(pre_max+nums[i],cur_max);//fmax(dp[i-2]+nums[i],dp[i-1]);
        pre_max=temp;
    }
    return cur_max;
}

第二题

方法一：

int robs(int *nums,int begin,int i)
{
    if(i<begin)
        return 0;
    return fmax(robs(nums,begin,i-2)+nums[i],robs(nums,begin,i-1));
}

int rob(int* nums, int numsSize){
    if(numsSize==1)return nums[0];
    return fmax(robs(nums,0,numsSize-2),robs(nums,1,numsSize-1));
}

方法二

int robs(int *nums,int begin,int i,int *memo)
{
    if(i<begin)
        return 0;
    else if(memo[i]>-1)
        return memo[i];
    memo[i]=fmax(robs(nums,begin,i-2,memo)+nums[i],robs(nums,begin,i-1,memo));
    return memo[i];
}

int rob(int* nums, int numsSize){
    if(numsSize==1)return nums[0];
    int *memo1=(int *)malloc(sizeof(int)*numsSize);
    int *memo2=(int *)malloc(sizeof(int)*numsSize);
    memset(memo1,-1,sizeof(int)*numsSize);
    memset(memo2,-1,sizeof(int)*numsSize);
    return fmax(robs(nums,0,numsSize-2,memo1),robs(nums,1,numsSize-1,memo2));
}

方法三

int rob(int* nums, int numsSize){
    if(numsSize==1)return nums[0];
    int *dp1=(int *)malloc(sizeof(int)*(numsSize+1));
    int *dp2=(int *)malloc(sizeof(int)*(numsSize+1));
    memset(dp1,0,sizeof(int)*(numsSize+1));
    memset(dp2,0,sizeof(int)*(numsSize+1));
    for(int i=2;i<numsSize+1;i++)
    {
        dp1[i]=fmax(dp1[i-1],dp1[i-2]+nums[i-2]);
        dp2[i]=fmax(dp2[i-1],dp2[i-2]+nums[i-1]);
    }
    return fmax(dp1[numsSize],dp2[numsSize]);
}

方法四：

int rob(int* nums, int numsSize){
    if(numsSize==1)return nums[0];
    int cur_max1=0,cur_max2=0;//dp[-1]=0;
    int pre_max1=0,pre_max2=0;//dp[-2]=0;
    for(int i=0;i<numsSize-1;i++)
    {
        int temp=cur_max1;//保存dp[i-1];
        cur_max1=fmax(pre_max1+nums[i],cur_max1);//fmax(dp[i-2]+nums[i],dp[i-1]);
        pre_max1=temp;
        temp=cur_max2;
        cur_max2=fmax(pre_max2+nums[i+1],cur_max2);
        pre_max2=temp;
    }
    return fmax(cur_max1,cur_max2);
}

第三题

方法一：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int rob(struct TreeNode* root){
    if(root==NULL)return 0;
    rob(root->left);
    rob(root->right);
    int a=0,b=root->val;
    if(root->left!=NULL)
    {
        a+=root->left->val;
        if(root->left->left!=NULL)
            b+=root->left->left->val;
        if(root->left->right!=NULL)
            b+=root->left->right->val;
    }
    if(root->right!=NULL)
    {
        a+=root->right->val;
        if(root->right->left!=NULL)
            b+=root->right->left->val;
        if(root->right->right!=NULL)
            b+=root->right->right->val;
    }
    root->val=fmax(a,b);
    return root->val;
}

方法二：

void robs(struct TreeNode* root,int *isrobval,int *notrobval){
    if(root==NULL)return;
    int isleftval=0;
    int notleftval=0;
    int isrightval=0;
    int notrightval=0;
    robs(root->left,&isleftval,&notleftval);
    robs(root->right,&isrightval,&notrightval);
    *isrobval=root->val+notleftval+notrightval;
    *notrobval=isleftval+isrightval;
    *isrobval=fmax(*isrobval,*notrobval);
}

int rob(struct TreeNode* root)
{
    int isrobval=0,notrobval=0;
    robs(root,&isrobval,&notrobval);
    return isrobval;
}