DP-背包九讲

已于 2024-02-02 16:54:52 修改
阅读量1.2k 收藏 19
点赞数 40
分类专栏： 动态规划 文章标签： 算法 动态规划
于 2024-01-12 10:24:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68738523/article/details/135545078
版权

01背包问题

n个物品，背包体积为V。

我们可以用是否选择了第i个物品作为状态转移的依据。我们将当前的状态定义为：“只在前i个物品中选，已使用体积为j”，这个状态可以由两个状态得到：“选择了第i个物品”和“未选择第i个物品”。

如下图所示，可以列出状态转移方程：

结合状态转移方程可知，我们可以用一个二维数组来实现这个过程。

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int N,V,v[1010],w[1010],f[1010][1010];
    scanf("%d%d",&N,&V);
    for(int i=1;i<=N;i++) scanf("%d%d",&v[i],&w[i]);
    
    for(int i=1;i<=N;i++)
    {
        for(int j=0;j<=V;j++)
        {
            f[i][j]=f[i-1][j];
            if(j>=v[i]) f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
        }
    }
    printf("%d",f[N][V]);
}

在这里有一个优化，可以发现，每次更新状态时，其实只需要用到第i-1层的状态，因此，我们没有必要将此前的0~i-2层都保存下来，我们可以直接去掉第一维。因为当更新第i维时，f值正好处于i-1维，若直接去掉，有：

f[j]=max(f[j], f[j-v[i]]+w[i])

也就是说，我们需要用f[j-v[i]]这个状态来更新f[j]，因此要后更新f[j-v[i]]，所以此时我们对j的遍历应该是从V开始，而不是从0开始。

最后的代码如下：

#include<iostream>
using namespace std;
const int N=1010;
int n,V;
int v[N],w[N];
int f[N];
int main()
{
    scanf("%d%d",&n,&V);
    for(int i=1;i<=n;i++) scanf("%d%d",&v[i],&w[i]);
    for(int i=0;i<=n;i++)
        for(int j=V;j>=v[i];j--)
        {
            f[j]=max(f[j], f[j-v[i]]+w[i]);
        }
    printf("%d",f[V]);
}

完全背包问题

n种物品，每种物品有无限个，背包体积为V。

我们用是否选择了第i个物品作为状态转移的依据。将当前的状态定义为：“只在前i个物品中选，已使用体积为j”，这个状态可以由多个状态得到：“选择了第0，1，2.....x个第i种物品”。

如下图所示，可以列出状态转移方程：

根据状态转移方程，我们需要三重循环，时间复杂度很高，接下来进行优化。优化过程如下：

这样一来，只需要两重循环了，最后可以像01背包问题一样，将数组优化到1维。

#include<iostream>
using namespace std;
const int N=1010;
int n,V;
int v[N],w[N];
int f[N];
int main()
{
    scanf("%d%d",&n,&V);
    for(int i=1;i<=n;i++) scanf("%d%d",&v[i],&w[i]);
    for(int i=1;i<=n;i++)
        for(int j=v[i];j<=V;j++)
        {
                f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    printf("%d",f[V]);       
}

多重背包问题

n种物品，每种物品有s个，背包体积为V。

我们用是否选择了第i个物品作为状态转移的依据。将当前的状态定义为：“只在前i个物品中选，已使用体积为j”，这个状态可以由多个状态得到：“选择了第0，1，2.....s个第i种物品”。

如下图所示，可以列出状态转移方程：

在这里，我们用到了三层循环，接下来用二进制的思想进行优化。

对于0~1023，我们可以通过0、1、2、4、8...512拼凑出[0,1023]区间内的所有数字。

对于0~s，我们可以通过0、1、2、4、8...2的k次方（用2k表示）、s-2k拼凑出[0,s]区间内的所有数字，其中，2k要满足：2k<s，2(k+1)>s。

#include<iostream>
using namespace std;
const int N=20010,M=2010;
int n,V;
int f[M],v[N],w[N];
int main()
{
    scanf("%d%d",&n,&V);
    int cnt=0;
    for(int i=1;i<=n;i++) 
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        int k=1;
        while(k<=c)
        {
            cnt++;
            v[cnt]=k*a;
            w[cnt]=k*b;
            c-=k;
            k*=2;
        }
        if(c>0)
        {
            cnt++;
            v[cnt]=c*a;
            w[cnt]=c*b;
        }
    }
    for(int i=1;i<=cnt;i++)
        for(int j=V;j>=v[i];j--)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
                
    printf("%d",f[V]);
}

二进制优化可以让时间复杂度下降到O(nVlogs)，接下来介绍多重背包问题的终极优化方式——用单调队列进行优化。

类比完全背包问题进行思考，我们可以列出以下式子：

f[i,j]=max(f[i-1,j-v]+w,f[i-1,j-2v]+2w,...,f[i-1,j-kv]+kw)
f[i,j-v]=max(f[i-1,j-2v]+w,f[i-1,j-3v]+2w,...,f[i-1,j-(k+1)v]+kw)
f[i,j-2v]=max(f[i-1,j-3v]+w,f[i-1,j-4v]+2w,...,f[i-1,j-(k+2)v]+kw)
......

当减到r<v时，我们会发现，f[i,r]的式子列不出来了，也就是说，我们无法利用前面的状态转移出这个状态了。

f[i,r]=?

要怎么把这个状态转移出来呢？我们转换思路，r其实是j/v的余数，我们可以用余数来表示状态，进行状态转移。

f[i,0]=max(f[i-1,v],f[i-1,2v],...,f[i-1,kv])
f[i,1]=max(f[i-1,v+1],f[i-1,2v+1],...,f[i-1,kv+1])
......
f[i,r]=max(f[i-1,v+r],f[i-1,2v+r],...,f[i-1,kv+r])

而

f[i-1,v+r]=max(f[i-1,r)+w,f[i-1,r+v])
f[i-1,2v+r]=max(f[i-1,r)+2w,f[i-1,r+v]+w,f[i-1,r+2v])
......
f[i-1,kv+r]=max(f[i-1,r)+kw,...,f[i-1,r+(k-1)v]+w,f[i-1,r+kv])

做一个变式：

f[i-1,kv+r]=max(f[i-1,r),...,f[i-1,r+(k-1)v]-(k-1)w,f[i-1,r+kv]-kw)+kw

这样就可以得到我们的状态转移方程为：

f[i,j]=f[i-1][q[hh]]+(j-q[hh])/v*w

而要求解右边的这一串max，我们可以用单调队列来做。

单调队列的步骤可以参考之前写的这篇文章：

单调栈和单调队列的模板题-CSDN博客

步骤为：

①判断队头元素是否需要出队

        当队头元素的序号加上s*v后(即把所有第i种物品都放入背包)，仍然小于当前遍历到的体积，则队头元素出队。

②将所有“无用”元素出队

        当队尾元素小于当前已知最大元素使，队尾元素出队

③将当前元素入队

#include<iostream>
using namespace std;
const int N=1010,M=20010;
int n,V;
int f[N][M];
int main()
{
    scanf("%d%d",&n,&V);
    for(int i=1;i<=n;i++)
    {
        int v,w,s;
        scanf("%d%d%d",&v,&w,&s);
        for(int j=0;j<v;j++)
        {
            int q[M],hh=0,tt=-1;
            for(int k=j;k<=V;k+=v)
            {
                while(tt-hh>=0&&k>q[hh]+s*v) hh++;
                while(tt-hh>=0&&f[i-1][q[tt]]+(k-q[tt])/v*w<=f[i-1][k]) tt--;
                q[++tt]=k;
                f[i][k]=f[i-1][q[hh]]+(k-q[hh])/v*w; 
            }
        }
    }
    printf("%d",f[n][V]);
}

分组背包问题

n组物品，每组物品有s种，每组只能选1种，背包体积为V。

我们用是否选择了第i组物品作为状态转移的依据。将当前的状态定义为：“只在前i组物品中选，已使用体积为j”，这个状态可以由多个状态得到：“选择了第0，1，2.....s种第i组物品”。

如下图所示，可以列出状态转移方程：

#include<iostream>
using namespace std;
const int N=110;
int n,V;
int v[N][N],w[N][N],s[N];
int f[N];
int main()
{
    scanf("%d%d",&n,&V);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&s[i]);
        for(int j=1;j<=s[i];j++)
        {
            scanf("%d%d",&v[i][j],&w[i][j]);
        }
    }
    for(int i=1;i<=n;i++)
        for(int j=V;j>=1;j--)
        {
            for(int k=1;k<=s[i];k++)
            {
                if(j>=v[i][k]) f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
            }
        }
            
    printf("%d",f[V]);
}

背包问题求方案数

我们可以通过在dp过程中维护一个记录方案数的数组，完成对方案数的求解。

需要注意的是，可能存在多种方案都能得到最大结果的情况。

#include<iostream>
#include<cstring>
using namespace std;
const int N=1010,mod=1e9+7;
int n,V;
int f[N],g[N];
int main()
{
    memset(f,-1e10,sizeof(f));
    scanf("%d%d",&n,&V);
    g[0]=1;
    for(int i=1;i<=n;i++)
    {
        int v,w;
        scanf("%d%d",&v,&w);
        for(int j=V;j>=v;j--)
        {
            int t=max(f[j],f[j-v]+w);
            int s=0;
            if(t==f[j]) s+=g[j];
            if(t==f[j-v]+w) s+=g[j-v];
            if(s>=mod) s-=mod;
            g[j]=s;
            f[j]=t;
        }
    }
    int tres=0;
    for(int i=0;i<=V;i++) tres=max(tres,f[i]);
    int res=0;
    for(int i=0;i<=V;i++)
    {
        if(f[i]==tres) 
        {
            res+=g[i];
            if(res>=mod) res-=mod;
        }
    }
    printf("%d",res);
}

背包问题求方案

背包问题求方案的通用解法是：在dp完成后，我们对数组进行回溯，逐一判断每个物品选或不选（选了几个）。

如果要求字典序最小，我们会希望按照从第1件物品到第n件物品这样的顺序进行回溯，要达到这个目的，我们只需要在dp时从n~1来进行就可以了。

#include<iostream>
using namespace std;
const int N=1010;
int n,V;
int f[N][N];
int v[N],w[N];
int main()
{
    scanf("%d%d",&n,&V);
    for(int i=1;i<=n;i++) scanf("%d%d",&v[i],&w[i]);
    for(int i=n;i>=1;i--)  
        for(int j=0;j<=V;j++)
        {
            f[i][j]=f[i+1][j];
            if(j>=v[i]) f[i][j]=max(f[i][j],f[i+1][j-v[i]]+w[i]);
        }
    int vv=V;
    for(int i=1;i<=n;i++)
    {
        if(vv>=v[i]&&f[i][vv]==f[i+1][vv-v[i]]+w[i]) 
        {
            printf("%d ",i);
            vv-=v[i];
        }
    }
    
}

混合背包问题

7. 混合背包问题 - AcWing题库

解题

题目是01背包、完全背包、多重背包的结合，我们采用的思路是，将问题转化为多重背包来做。

01背包本身就是一个特殊的多重背包，对于完全背包问题，我们可选的最大物品数实际上只有总体积/物品体积，这就转化为多重背包了。

#include<iostream>
using namespace std;
const int N=1010;
int n,m;
int v[10*N],w[10*N],f[N];
int main()
{
    scanf("%d%d",&n,&m);
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        int vv,ww,ss;
        scanf("%d%d%d",&vv,&ww,&ss);
        if(ss==-1) ss=1;
        else if(ss==0) ss=m/vv;
        int k=1;
        while(k<=ss)
        {
            v[++cnt]=k*vv;
            w[cnt]=k*ww;
            ss-=k;
            k*=2;
        }
        if(ss>0)
        {
            v[++cnt]=ss*vv;
            w[cnt]=ss*ww;
        }
    }
    for(int i=1;i<=cnt;i++)
        for(int j=m;j>=v[i];j--)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
    printf("%d",f[m]);
}

有依赖的背包问题

10. 有依赖的背包问题 - AcWing题库

解题

dp思路如下：

在这里，我们使用体积而不是方案数来进行状态划分，如果使用方案数，若一个树根上有100个结点，我们的状态就是2的一百次方，会超。

#include<iostream>
#include<cstring>
using namespace std;
const int N=110;
int n,m;
int v[N],w[N];
int f[N][N];
int h[N],e[N],ne[N],idx=0;
void add(int a,int b)
{
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx++;
}
void dfs(int u)
{
    for(int i=m;i>=v[u];i--) f[u][i]=f[u][i-v[u]]+w[u];
    for(int i=h[u];i!=-1;i=ne[i])
    {
        int son=e[i];
        dfs(son);
        for(int j=m;j>=v[u];j--)
        {
            for(int k=0;k<=j-v[u];k++)
            {
                f[u][j]=max(f[u][j],f[u][j-k]+f[son][k]);
            }
        }
    }
}
int main()
{
    int root=0;
    memset(h,-1,sizeof(h));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        int p;
        scanf("%d%d%d",&v[i],&w[i],&p);
        if(p==-1) root=i;
        else add (p,i);
    }
    dfs(root);
    printf("%d",f[root][m]);
}

mlww-
关注
  • 40
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
动态规划（DP）-背包九讲
05-28
动态规划（DP）——背包九讲
动态规划（DP）-背包问题算法详解背包九讲
01-12
动态规划（DP）——背包问题算法详解[背包九讲]
DP - 背包九讲之混合背包
在读NLP硕士
07-14 239
混合背包问题 有 N 种物品和一个容量是 V 的背包。 物品一共有三类： 第一类物品只能用1次（01背包）； 第二类物品可以用无限次（完全背包）； 第三类物品最多只能用 si 次（多重背包）； 每种体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。 si=−1
DP - 背包九讲之多重背包
在读NLP硕士
07-14 462
多重背包问题 有 N 种物品和一个容量是 V 的背包。 第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤100 0<vi,wi,si≤100 输入样
DP - 背包九讲之完全背包
在读NLP硕士
07-14 251
完全背包问题 有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。 第 i 种物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0<vi,wi≤1000 输入样例 4
DP - 背包九讲之01背包
在读NLP硕士
06-12 205
01背包问题 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0<vi,wi≤1000 输入样例 4 5
背包九讲-2.0
09-16
《背包九讲-2.0》是一份深入探讨动态规划(DP)在解决背包问题中的应用的教程。动态规划是一种强大的算法思想，广泛应用于优化问题，尤其是那些具有重叠子问题和最优子结构特征的问题。背包问题作为动态规划的经典实例...
背包九讲(1)——01背包
01-03
问题引入 有n种物品，每种只有一个。第i种物品的体积为vi，价值为wi。...设dp(i,j)表示将第i,i+1,i+2,…,n个物品装入容量为j的背包中的最大价值，则： dp(i,j) = dp(i+1,j) dp(i,j) = max { dp(i,j)，dp(i+1,j-v[i
背包九讲--崔天翼 犇犇 orz
08-08
《背包问题九讲》是崔天翼（Tianyi Cui，又称dd_engi）撰写的一篇关于动态规划中背包问题的详细教程。该文首次发表于2007年，后于2011年9月进行了全面修订，现为2.0 alpha1版本，可在GitHub上找到最新的修订历史和...
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 884
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
代码随想录算法训练营第33天
m0_62262158的博客
07-10 154
【代码】代码随想录算法训练营第33天。
牛客小白月赛98 （个人题解）（补全）
最新发布
Wzh20060111的博客
07-13 254
前言：昨天晚上自己一个人打的小白月赛（因为准备数学期末已经写烦了），题目难度感觉越来越简单了（不在像以前一样根本写不了一点，现在看题解已经能看懂一点了），能感受到自己在不断进步，希望在暑假能更努力一点吧，，少打点游戏，多学学算法，还有web的学习也要抓起来了，这几天不是在看高数就是在打游戏，感觉好堕落。
【代码随想录算法训练营第六十二天|卡码网53.寻宝（prim算法和kruskal算法）】
weixin_46281930的博客
07-09 473
kruskal算法以边为导向，先把边按照长度从小到大排序，然后一个个检查边的两个端点是否在同一个集合中（这里使用并查集判断），在同一个集合中就不加入这个边，不在的话就加入。可以把所有已经使用过的结点看作一个整体，然后把他们相接的结点的结点顶点边中进行选择，选择最短的一条边把该结点入树，某种程度来说也是一种贪心？1.选择当前最短入树结点；3.更新结点距离最小生成树的距离。
Leetcode104.求二叉树的最大深度
知道这个有什么用？
07-10 297
【代码】Leetcode104.求二叉树的最大深度。
【代码随想录】【算法训练营】【第62天】 [卡码108]冗余连接 [卡码109]冗余连接II
weixin_54954007的博客
07-08 587
思路及算法思维，指路。题目来自。day 62，又是一个周一，ding~
代码随想录算法训练营day76 | Floyd 算法精讲、A * 算法精讲
sunflowers11的博客
07-09 418
本次题目来自于卡码网。
代码随想录算法训练营DAY58｜101.孤岛的总面积、102.沉没孤岛、103. 水流问题、104.建造最大岛屿
Greeneril_的博客
07-11 245
忙。。。写了好久。。。。慢慢补吧。
【代码随想录】【算法训练营】【第67天】 [卡码97]小明逛公园 [卡码127]骑士的攻击
weixin_54954007的博客
07-13 249
思路及算法思维，指路。题目来自。day 67，周六，ding~
微软DP-900.pdf
06-13
"微软DP-900.pdf是与微软认证相关的学习资料，可能是为了帮助考生准备DP-900考试。这份文档包含了多个主题，其中至少有一个话题涉及到数据分析的不同类型，包括描述性、诊断性、预测性和认知分析。另一个话题讨论了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值