记忆化搜索--(01背包,完全背包,最长公共子序列,最长上升子序列)

记忆化动态规划学习笔记

1.记忆化搜索与动态规划

01背包问题1

n的物品都有自己的wi,vi,背包最多可装载的重量为W,背包里的物体价值最大(1<
暴力写法,存在较多的重复计算,复杂度O(pow(2,k))
从第i个物品挑选总重小于j的部分

int rec(int i, int j) {
    int res;
    if (i == n)  res = 0;//无剩余
    else if (j < w[i])res = rec(i + 1, j);//不够
    else res = max(rec(i + 1, j), rec(i + 1, j - w[i])+v[i]);
    return res;
}

记忆化搜索,复杂度O(nw)nw为参数组合数量

int sovle(int i, int j) {
    //记忆化保存
    if (dp[i][j] > 0)return dp[i][j];
    int res;
    if (i == n)res = 0;
    else if (j < w[i])res = rec(i + 1, j);
    else res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
    return dp[i][j] = res;
}

定义:dp[i+1][j]:从0到i(i+1个)物品中选出总重量不超过j的最大物品的价值和。(假设物体从第0个开始)

    1.dp[0][j]=0   (dp[i][0]=0如果物品价值都大于0)
    2.dp[i+1][j]=dp[i][j]  (j

写法如下:i逆向进行也可以,此处不写

void solve() {
    for(int i=0;i

应用:最长公共子序列(Longest Common Subsequence)

定义:dp[i][j]:两个子序列分别到i和j的位置的LCS
状态转移如下:
dp[i+1][j+1]=max(dp[i+1][j],dp[i][j+1])(s[i+1]!=s[j+1])
dp[i+1][j+1]=dp[i][j]+1(其他)

void solve() {
    for(int i=0;i

2.进一步探索

完全背包问题

n的物品都有自己的wi,vi,背包最多可装载的重量为W,怎样使得背包里的物体的价值最大,每个物品可以选择任意多(1<
思考一下,首先我们可能会想到枚举k(k为每个物品选择的个数,现在就存在一个三重循环)进一步思考,由于每个物品可以选择任意多,当我们停留在选择某个物品上面,只有状态j会发生改变,所以转态转移如下
定义:dp[i+1][j]:从0到i(i+1个)物品中选出总重量不超过j的最大物品的价值和。(假设物体从第0个开始)
1. dp[0][j]=0 (dp[i][0]=0如果物品价值都大于0)
2.dp[i+1][j] (j dp[i+1][j]=max{dp[i][j],dp[i+1][j-w[i]]+v[i]}
写法于上面类似

void solve() {
    for(int i=0;i j)dp[i + 1][j] = dp[i][j];
            else dp[i + 1][j] = max(dp[i][j], dp[i + 1][j - w[i]] + v[i]);
        }
}

01背包和完全背包重复利用数组的情况

void solve() {
    for(int i=0;i=w[i]; j--) {
            dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
        }
}
void solve() {
    for(int i=0;i

dp[i + 1][j] = max(dp[i][j], dp[i+1][j - w[i]] + v[i])这种情况计算[i+1][j]时候只用到[i]和[i+1],所以可以用到滚动数组,具体见白书。

01背包问题2

n的物品都有自己的wi,vi,背包最多可装载的重量为W,怎样使得背包里的物体的价值最大1<
对于这个问题,相比之前的01背包,只是修改了限制条件的大小,之前的复杂度为O(nW),这个复杂度对于现在的规模是不够用了的,但是价值的范围较小,我们可以改变dp的对象。
定义:
dp[i+1][j]:前i个物品挑选总价值为J的最小总重量(不存在是为INF)。
dp[0][0]=0
dp[0][j]=INF
前i个物品挑选总价值为j状态可以由前i-1个物品挑选总价值为j的状态和前前i-1个挑选总价值为j-v[i]的状态转移而来。于是:
dp[i+1][j]=max(dp[i][j],dp[i][j-v[i]]+w[i])
最终的答案就是dp[n][j]<=W的最大j值。
时间复杂度为O(n*sigma(vi)),这种题就是要根据问题规模来设定算法的对象。

int solve() {
    //设立初状态
    //N表示n的最大值,V表示总价值的最大
    fill(dp[0], dp[0] + N * V + 1, INF);
    dp[0][0] = 0;
    for(int i=0;i

多重部分和问题

有n个大小不同的数字ai,每个数字有mi个,判断能否从中选择部分使得他们的和为K(1<=n<=100,1<=ai,mi<=1e5,1<=K<=1e5)
定义dp[i+1][j]:对于前i个数字加和得到j时,第i个数字的最多剩余(不能加和得到j的情况为-1)

dp[i+1][j]=m[i](dp[i][j]>=0,前i-1个数字已经加和得到j,此时第i个数字不需要加入)
          =-1(j

重复利用数组,还是有点不太清晰。

void solve() {
    memset(dp, -1, sizeof(dp));
    dp[0] = 0;
    for(int i=0;i= 0)dp[j] = m[i];
            else if (j < a[i] || dp[j - a[i]] <= 0)dp[j] = -1;
            else dp[j] = dp[j - a[i]] - 1;
        }
}

最长上升子序列(Longest Increasing Subsequence)

在一个长为n的数列中(a0,a1,a2,a3...,an-1)。请你求出最长的上升子序列长度。(1<=n<=1000,0<=ai<=1000000)
定义dp[i]:以a[i]为结尾的最长上升子序列长度。
dp[i]=max{1, dp[j]+1|j

int n;
int a[MAX_N];
int dp[MAX_N];
void solve(){
    int res=0;
    for(int i=0;i

转载于:https://www.cnblogs.com/gzr2018/p/10406452.html

你可能感兴趣的:(记忆化搜索--(01背包,完全背包,最长公共子序列,最长上升子序列))