从记忆化搜索到递推

本篇博客的内容学习自"灵茶山艾府" 视频链接

打家劫舍

从最后一个节点开始考虑,因为因为约束最小,设当前结点为i,如果不偷i结点,就考虑i-1个结点,如果偷i结点,就考虑i-2个节点,所以dfs(i)=max(dfs(i-1),dfs(i-2)+nums[i])

回溯代码

class Solution {
public:
    int dfs(int i,vector<int>&nums)
    {
        if(i<0)
        return 0;
        return max(dfs(i-1,nums),dfs(i-2,nums)+nums[i]);
    }
    int rob(vector<int>& nums) {
        return dfs(nums.size()-1,nums);
    }
};

由于回溯代码的时间复杂度是指数级别的,所以超时了,但其中有很多重复计算,如果能存下来,可以大大降低时间复杂度

记忆化+回溯

class Solution {
public:
    vector<int>cache=vector<int>(105,-1);
    int dfs(int i,vector<int>&nums)
    {
        if(i<0)
        return 0;
        if(cache[i]!=-1)
        return cache[i];
        int res=max(dfs(i-1,nums),dfs(i-2,nums)+nums[i]);
        cache[i]=res;
        return res;
    }
    int rob(vector<int>& nums) {
        return dfs(nums.size()-1,nums);
    }
};

上述代码已经非常不错了,但是空间复杂度是O(n)的,那么可不可以改成O(1)呢,答案是可以的,在这之前我们先考虑如何用非递归的方式实现上述代码,容易发现上述代码是从上往下,递,再从下往上计算结果,这便是"归",所以可以保留"归"的过程,而舍弃"递"的过程.这便叫"递推".

从记忆化搜索到递推

dfs             ---->f数组

递归           ------->循环

递归边界    ----->数组初始值

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

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

f[i+2]=max(f[i+1],f[i]+nums[i]) //下标都偏移一下(+2),防止产生负数下标

递推代码

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

递推的代码仍是O(n)的,而我们的目的是O(1) 观察我们的递推的公式,可以发现要计算f[i]只需知道f[i-1]与f[i-2],即上一个状态和上上一个状态,只要动态更新上一个状态和上上一个状态就行

空间复杂度O(1)代码

class Solution {
public:
    int rob(vector<int>& nums) {
        int n=nums.size();
        int f0=0,f1=0,f2;
        for(int i=0;i<nums.size();i++)
        {
           f2=max(f1,f0+nums[i]);
           f0=f1;
           f1=f2;
        }
        return f2;
    }
};

这段代码就很完美了,O(n)的时间复杂度,O(1)的空间复杂度