动态规划+记忆化搜索

目录

一：整数切割 

法一：记忆化搜索

 法二：动态规划

二：打家劫舍

一：记忆化搜索

二：动态规划

---

一：整数切割 

---

首先1无法分割，所以1的最大乘积是1

6可以分割：

两个数的和：1+5，2+4，3+3

三个数的和：1+2+3，1+1+4，2+2+2

四个数的和：1+1+1+3，1+1+2+2

五个数的和：1+1+1+1+2

六个数的和：1+1+1+1+1+1

发现有很多重叠子问题：1+分割5的情况；2+分割4的情况；3+分割3的情况。。。。

最优子结构+重叠子问题

法一：记忆化搜索

class Solution {
private:
    vector<int> memo;
    int breakInteger(int n){
        if(n==1) return 1;//1不能分割
        if(memo[n]!=-1) return memo[n];//当前1已经分割了
        /*分割过程*/
        int res=-1;//返回结果
        for(int i=1;i<n;i++){//数字分割成i和n-i
             cout<<"分割"<<n-i<<":"<<breakInteger(n-i)<<endl;
             res=max(res,max(i*(n-i),i*breakInteger(n-i)));
        }
        //记录memo[n]的值
        memo[n]=res;
        return res;
    }
public:
    int integerBreak(int n) {
        memo=vector<int>(n+1,-1);
        return breakInteger(n);
    }
};

说白了就是比较当前的拆分i和n-i的乘积与i乘以分解（n-i）最大乘积

 法二：动态规划

class Solution {
public:
    int integerBreak(int n) {
        vector<int> memo(n+1,-1);
        memo[1]=1;
        for(int i=2;i<=n;i++){
            for(int j=1;j<i;j++)
               memo[i]=max(memo[i],max(j*(i-j),j*memo[i-j]));
        }
        return memo[n];
    }
};

从小到大一次记录分割n的最大值；然后从j开始不停判断

注意：

因为memo[i]在j分割后会被赋值，j变化后，memo[i]已经不是-1了，所以继续带上判断

二：打家劫舍

 

 分析：自顶向下 

每次选一个后，范围就会缩小其后的一个

---

状态-----考虑从[x,...,n-1]中偷取房子-----又叫函数的定义

状态的转移-----需要范围的起点

f(0)=max{v(0)+f(2),v(1)+f(3),v(2)+f(4),....,v(n-1)}

意思：取了v(0)后，起点变成2.

这就是：状态转移方程

一：记忆化搜索

#include<iostream>
#include<vector>
using namespace std;
class Solution {
private:
    vector<int> memo;
    /*考虑从nums[index,...,nums.size()-1]中偷*/
    int tryRob(vector<int> &nums,int index){
        if(index>=nums.size()) return 0;
        if(memo[index]!=-1) return memo[index];
        int res=0;
        for(int i=index;i<nums.size();i++){
            res=max(res,nums[i]+tryRob(nums,i+2));
        }
        memo[index]=res;
        return res;
    }
public:
    int rob(vector<int> &nums)
    {
        memo=vector<int>(nums.size(),-1);
        return tryRob(nums, 0);
    }
};
int main(){
    vector<int> mm={9,2,5,8,4,33,4};
    cout<<Solution().rob(mm)<<endl;
    return 0;
}

二：动态规划

class Solution {
public:
    int rob(vector<int> &nums) {
        int n=nums.size();
        /*memo[i]:nums[i,....,n-1]的最大收益*/
        vector<int> memo(n,-1);
        //注意：起点应该是memo[n-1]
        memo[n-1]=nums[n-1];
        for(int i=n-2;i>=0;i--){//计算memo
            for(int j=i;j<n;j++)
               memo[i]=max(memo[i],nums[j]+(j+2<n ?memo[j+2]:0));
        }
        return memo[0];
    }
};

 从后向前考虑问题