leetcode-每日一题-打家劫舍-213-(dp,中等,经典)

这道打家劫舍题十分经典序列行动态规划，分为两种，第一种简单，只要能想出来运动方程即可，也就是说这一步该怎么走，第一种可能性就是偷我们要不就是从前一次没有偷的值所以第一种类型很明显可以看出来要分为二维进行存储当前是偷了还是没有偷，有了这个思路我们很好写出方程

 所以我们方程就可以写成下面这样

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

最后的max我们直接求偷和没偷的最大值即可 

fmax(dp[0][numsSize-1],dp[1][numsSize-1])

下面是完整的代码 

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

 时间超越了百分之百，空间可以用动态数组进行缩小，到后面的化空间复杂度就是o(1),时间复杂度就是o(n)。

 第二种类型相对于第一种类型增加了一个首尾相连模式，也就是说当你偷了第一个就不可以在偷第二个了，这个就和咱们传统意义上面的划分行动态规划就不一样了，但是当你思考过后你就会发现其实里面藏有奥秘，当你忽略第一个房间的时候我们就可以无视掉首位呼应这个条件了，为什么这么说呢？因为当你不看第一个的时候，你最多也就只能获得到最后一个房间的金币，所以同理当你不看最后一个房间的时候，你就也最多只能获得到最后一个房间的金币，那么按照这个思路，你只要第一次dp完了之后将数组进行颠倒，或者说你从后往前进行遍历也行，时间复杂度还是o(n),空间复杂度还是O(1)，很完美只不过代码不是很美观而已，下面看我写的成品。

void zhuanhuan(int *nums,int numsSize)
{
    int e;
    for(int i=0,j=numsSize-1;i<=j;i++,j--)
    {
        e=nums[i];
        nums[i]=nums[j];
        nums[j]=e;
    }
}
int rob(int* nums, int numsSize){
    if(numsSize==0)
    {
        return 0;
    }
    if(numsSize==1)
    {
        return nums[0];
    }
    if(numsSize==2)
    {
        return fmax(nums[0],nums[1]);
    }
    int dp[2][numsSize],max=-1;
    memset(dp,0,sizeof(dp));
    dp[0][0]=0,dp[1][0]=nums[0],dp[0][1]=nums[0],dp[1][1]=nums[1];
    for(int i=2;i<numsSize-1;i++)
    {
        dp[0][i]=fmax(dp[0][i-1],dp[1][i-1]);
        dp[1][i]=fmax(dp[0][i-1]+nums[i],dp[1][i-2]+nums[i]);
    }
    max=fmax(max,fmax(dp[0][numsSize-2],dp[1][numsSize-2]));
    zhuanhuan(nums,numsSize);
    for(int i=0;i<numsSize;i++)
    {
        printf("%d ",nums[i]);
    }
    max=fmax(max,fmax(dp[0][numsSize-1],dp[1][numsSize-1]));
    memset(dp,0,sizeof(dp));
    dp[0][0]=0,dp[1][0]=nums[0],dp[0][1]=nums[0],dp[1][1]=nums[1];
    for(int i=2;i<numsSize-1;i++)
    {
        dp[0][i]=fmax(dp[0][i-1],dp[1][i-1]);
        dp[1][i]=fmax(dp[0][i-1]+nums[i],dp[1][i-2]+nums[i]);
    }
    max=fmax(max,fmax(dp[0][numsSize-2],dp[1][numsSize-2]));
    return max;
}

 虽然代码看起来很冗余但是你看时间已经超过了百分之百的人，只要把空间进行修改肯定也可以上90，我没有修改咱们主要理解思路即可 

 

 很荣幸之前看到过一个dp的全套讲解，也就是下面的这个图里面包含的所有的dp的类型几乎已经覆盖完了，这套视频价值599美刀，去年我看过全套的，是美国那边的讲师讲的，讲的真的很不错，只不过现在已经没资源了，只能去买了，我可以把图放在下面大家可以参考参考