DP背包问题及优化详解（全）

最新推荐文章于 2024-03-22 14:56:44 发布

Galactus_hao

最新推荐文章于 2024-03-22 14:56:44 发布

阅读量818

点赞数 7

分类专栏：算法分析文章标签：算法动态规划

本文链接：https://blog.csdn.net/z_h666/article/details/119568321

版权

算法分析专栏收录该内容

7 篇文章 0 订阅

订阅专栏

背包问题

01背包问题

原题链接

抽象题目：
有 $n$ 件物品和一个容量为 $v$ 的背包。第i件物品的体积是v[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

特点：每个物品最多选1次。

二维数组实现方式：

状态转换方程：dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i])

状态转换方程解释：

对于第i个物品有两种情况：

1.不选第i个物品时：dp[i][j]=dp[i-1][j]
2.选择第i个物品时：dp[i][j]=dp[i-1][j-v[i]]+w[i]

所以取最大的就ok：dp[i][j]=max{1.,2.}

初始化：dp[0][0]=0;

原题的代码实现：

#include<bits/stdc++.h>
using namespace std;
const int N=310;
int dp[N][N],w[N],v[N];
int n,m;
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            dp[i][j]=dp[i-1][j];
            if(j>=v[i])
                dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
            // cout<<dp[i][j]<<" ";
        }
        // cout<<endl;
    }
    int ans=0;
    for(int i=1;i<=m;i++)ans=max(ans,dp[n][i]);
    cout<<ans<<endl;
    return 0;
}

优化空间复杂度
以上方法的时间和空间复杂度均为O(N*V)，其中时间复杂度基本已经不能再优化了，但空间复杂度却可以优化到O(V)。

一维数组实现

先考虑上面讲的基本思路如何实现，肯定是有一个主循环i=1…N，每次算出来二维数组f[i][0…V]的所有值。那么，如果只用一个数组f [0…V]，能不能保证第i次循环结束后f[v]中表示的就是我们定义的状态f[i][v]呢？f[i][v]是由f[i-1][v]和f[i-1] [v-c[i]]两个子问题递推而来，能否保证在推f[i][v]时（也即在第i次主循环中推f[v]时）能够得到f[i-1][v]和f[i-1][v -c[i]]的值呢？事实上，这要求在每次主循环中我们以v=V…0的顺序推f[v]，这样才能保证推f[v]时f[v-c[i]]保存的是状态f[i -1][v-c[i]]的值。伪代码如下：

for i=1…N
for v=V…0
f[v]=max{f[v],f[v-c[i]]+w[i]};

其中的f[v]=max{f[v],f[v-c[i]]}一句恰就相当于我们的转移方程f[i][v]=max{f[i-1][v],f[i- 1][v-c[i]]}，因为现在的f[v-c[i]]就相当于原来的f[i-1][v-c[i]]。如果将v的循环顺序从上面的逆序改成顺序的话，那么则成了f[i][v]由f[i][v-c[i]]推知，与本题意不符，但它却是另一个重要的背包问题P02最简捷的解决方案，故学习只用一维数组解01背包问题是十分必要的。

一维数组实现的理论解释摘自：dd大牛的《背包九讲》

原题的实现代码：

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int dp[N],w[N],v[N];
int n,m;
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>v[i]>>w[i];
    for(int i=1;i<=n;i++){
        for(int j=m;j>=v[i];j--){
            dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
            // cout<<dp[j]<<" ";
        }
        // cout<<endl;
    }
    // for(int i=0;i<=m;i++)cout<<dp[i]<<" ";
    // cout<<endl;
    cout<<dp[m]<<endl;
    return 0;
}

完全背包问题

原题链接

抽象题目：有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是v[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

特点：每种物品可以选多次

和01背包的区别：在枚举时01背包内层循环体积从大到小进行枚举；完全背包是从小到大枚举体积

状态转换方程：
$i : 1 - > n$

$j : v - > m$

$d p [j] = m a x (d p [j], d p [j - v [i]] + w [i])$

数学归纳法（递推）：

1.假设考虑前i-1个物品之后，所有的dp[j]都是正确的
2.来证明，考虑完第i个物品后，所有的dp[j]也都是正确的

对于某个j而言，如果最优解中包含k个v[i]:

$d p [j - k * v [i]];$

$d p [j - (k - 1) * v [i] - v [i]] + w [i] 包含 1 个 v [i]$

$\cdot \cdot \cdot \cdot \cdot \cdot$

$d p [j] : d p [j - v [i]] + w [i];$

原题代码实现：

#include<bits/stdc++.h>
using namespace std;
const int N=10010;
int dp[N],w,v,n,m;
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        cin>>v>>w;
        for(int j=v;j<=m;j++)
            dp[j]=max(dp[j],dp[j-v]+w);
    }
    cout<<dp[m]<<endl;
    return 0;
}

多重背包问题

多重背包1原题链接

抽象题目：有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是v[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

特点：物品的数量有特定的限制

和01背包的区别：在01背包的基础上再加一重循环来判断个数。

状态转换方程：
$i : 1 - > n$

$j : m - > v$

$d p [j] = m a x (d p [j], d p [j - v] + w, d p [j - 2 * v] + 2 * w, \cdot \cdot \cdot \cdot \cdot);$

时间复杂度: $O(n^3)$

解释：最大的情况的包括选第i个物品0->s个都有可能，所以从0->s个中取一个最大值。

原题代码实现：

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int dp[N],v,w,s,n,m;
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        cin>>v>>w>>s;
        for(int j=m;j>=0;j--)
            for(int k=1;k<=s&&k*v<=j;k++)
                dp[j]=max(dp[j],dp[j-k*v]+k*w);
    }
    cout<<dp[m]<<endl;
    return 0;
}

多重背包的二进制优化方法：

多重背包2原题链接

优化最终结果：转化为01背包的时间复杂度
优化物品的选择个数：
1.如果将所有的个数都加入到原来的v和w中
也就是说：如果物品1有7个，则可以将物品1*7加入到原来的v，w中（显然这种加入的方法和原来的时间复杂度是一样的）
2.由1.的拆解过程我们可以想到用 $l o g (n)$ ,来进行拆解的办法。
例如：物品1有10个，那么物品1就可以插接拆解成1,2,4,3。这样的话用这四个数就可以表示0~10中的数
如：选7个就可4+3；选8个就可4+4；选9个就可2+4+3。所以用 $l o g (s)$ 个数就可以表示出0~s中任意一个数了。

需要注意的是：选择的 $l o g (s)$ 个数需要存储起来，以便后面的使用。

原题代码实现：

#include<bits/stdc++.h>
using namespace std;
const int N=2010;
int f[N],n,m;
struct Good{
    int v,w;
};
int main(){
    vector<Good>good;
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        int v,w,s;
        cin>>v>>w>>s;
        for(int k=1;k<=s;k*=2){
            s-=k;
            good.push_back({v*k,w*k});
        }
        if(s>0) good.push_back({v*s,w*s});
    }
    for(auto g:good)
        for(int j=m;j>=g.v;j--)
            f[j]=max(f[j],f[j-g.v]+g.w);
    cout<<f[m]<<endl;
    return 0;
}

多重背包单调队列优化

多重背包3原题链接

单调队列的基本算法思想:

滑动窗口：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pWLpWD73-1628574940471)(./图片/单调队列.png)]

多重背包问题的状态方程： $f [j] = m a x (f [j - v] + w, f [j - 2 v] + 2 w + \cdot \cdot \cdot \cdot + f [j - k * v] + k * w)$

每次增加的时候都是： $v ： 1 - k ， w ： 1 - k;$

$f [0]$

$f [v] = 1 * w;$

$f [2 v] = 2 * w;$

$\cdot \cdot \cdot \cdot$

$f [k * v] = k * w;$

转化为一个等差数列

单调队列优化多重背包问题
参考视频链接

单调队列的滑动窗口问题:
参考链接

原题代码实现：

#include<bits/stdc++.h>
using namespace std;
const int N=20010;
int n,m;
int f[N],g[N],q[N];
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        int v,w,s;
        cin>>v>>w>>s;
        memcpy(g,f,sizeof f);
        for(int j=0;j<v;j++){
            int hh=0,tt=-1;
            for(int k=j;k<=m;k+=v){//单调队列优化
                f[k]=g[k];
                if(hh<=tt&&k-s*v>q[hh]) hh++;
                if(hh<=tt) f[k]=max(f[k],g[q[hh]]+(k-q[hh])/v*w);
                while(hh<=tt&&g[q[tt]]-(q[tt]-j)/v*w<=g[k]-(k-j)/v*w) tt--;
                q[++tt]=k;
            }
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

混合背包问题

原题链接

抽象题目：就是将01背包和完全背包和多重背包混合起来

解题的思路：因为多重背包的时间复杂度较大，所以用多重背包的二进制优化方法的思路来想。

原题实现代码：

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int f[N],n,m;
struct Thing{
    int k;//类型：-1：01背包，0：完全背包
    int v,w;//体积，价值
};
vector<Thing>T;
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){//二进制分配
        int v,w,s;
        cin>>v>>w>>s;
        if(s<0) T.push_back({-1,v,w});
        else if(s==0) T.push_back({0,v,w});
        else {
            for(int k=1;k<=s;k*=2){
                s-=k;
                T.push_back({-1,v*k,w*k});
            }
            if(s>0) T.push_back({-1,v*s,w*s});
        }
    }
    for(auto t:T){//选择
        if(t.k<0){
            for(int j=m;j>=t.v;j--)
                f[j]=max(f[j],f[j-t.v]+t.w);
        }
        else {
            for(int j=t.v;j<=m;j++){
                f[j]=max(f[j],f[j-t.v]+t.w);
            }
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

二维费用的背包问题

原题链接

抽象题目：对于每件物品，具有两种不同的费用；选择这件物品必须同时付出这两种代价；对于每种代价都有一个可付出的最大值（背包容量）。问怎样选择物品可以得到最大的价值。设这两种代价分别为代价1和代价2，第i件物品所需的两种代价分别为a[i]和b[i]。两种代价可付出的最大值（两种背包容量）分别为V和U。物品的价值为w[i]。

在二维背包问题时多了个限制条件，只需要将前几个背包问题上多加入一维然后多加一层循环即可解决。

原题代码：

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int n,m,v;
int f[N][N];
int main(){
    cin>>n>>v>>m;
    for(int i=0;i<n;i++){
        int a,b,w;
        cin>>a>>b>>w;
        for(int j=v;j>=a;j--)
            for(int k=m;k>=b;k--)
                f[j][k]=max(f[j][k],f[j-a][k-b]+w);
    }
    cout<<f[v][m]<<endl;
    return 0;
}

分组背包问题

原题链接

抽象题目：有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。这些物品被划分为若干组，每组中的物品互相冲突，最多选一件。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

可以类比多重背包问题：可以看成多重背包中的个数，打包1个，打包2个···打包n个。
多重背包问题实际上时分组背包问题的一种特殊情况，分组问题可以用多重背包问题的普通方法来求解

#include<bits/stdc++.h>
using namespace std;
const int N=110;
int f[N],v[N],w[N];
int n,m;
int main(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        int s;
        cin>>s;
        for(int j=0;j<s;j++) cin>>v[j]>>w[j];
        for(int j=m;j>=0;j--)
            for(int k=0;k<s;k++)
                if(j>=v[k])
                    f[j]=max(f[j],f[j-v[k]]+w[k]);
    }
    cout<<f[m]<<endl;
    return 0;
}

背包问题求方案数

题目链接

题目描述：

有 $N$ 件物品和一个容量是 $V$ 的背包。每件物品只能使用一次。
第 $i$ 件物品的体积是 $v_i$ ，价值是 $w_i$ 。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最优选法的方案数。注意答案可能很大，请输出答案模 $10^9+7$ 的结果。

解题思路：
本题求01背包的最佳方案数，那么定义两个数组： $f [N], c n t [N]$
$f [i]$ 用来存储背包容积为 $i$ 时的最佳方案的总价值，

$c n t [i]$ 为背包容积为 $i$ 时总价值为最佳的方案数

先初始化所有的 $c n t [i]$ 为 $1$ ，因为背包里什么也不装也是一种方案

外层循环 $n$ 次，每次读入新物品的 $v, w$
求出装新物品时的总价值，与不装新物品时作对比

如果装新物品的方案总价值更大，那么用 $f [j - v] + w$ 来更新 $f [j]$ ，用 $c n t [j - v]$ 更新 $c n t [j]$
如果总价值相等，那么最大价值的方案数就多了 $c n t [j - v]$ 种

代码实现：

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
const int mod = 1e9+7; 
int f[N],g[N],value,n,m;
int main(){
    cin>>n>>m;
    for(int i=0;i<=n;i++)g[i]=1;
    for(int i=1;i<=n;i++){
        int v,w;
        cin>>v>>w;
        for(int j=m;j>=v;j--){
            value=f[j-v]+w;
            if(value>f[j]){
                f[j]=value;
                g[j]=g[j-v];
            }else if(value==f[j]){
                g[j]=(g[j]+g[j-v])%mod;
            }
        }
    }
    cout<<g[m]<<endl;
    return 0;
}

求背包问题的方案

题目链接

题目描述：有 $N$ 件物品和一个容量是 $V$ 的背包。每件物品只能使用一次。
第 $i$ 件物品的体积是 $v_i$ ，价值是 $w_i$ 。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 $1 \dots N$ 。

要用二维的01背包问题的解法，因为需要求具体的方案，所以要保留原来的状态。思路就是反推方案。

代码实现：

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int f[N][N],v[N],w[N];
int n,m;
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++)cin>>v[i]>>w[i];
    for(int i=n;i>=1;i--)
        for(int j=0;j<=m;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]);
        }

    int res=m;
    for(int i=1;i<=n;i++){
        if(f[i][res]==f[i+1][res-v[i]]+w[i]&&v[i]<=res){
            cout<<i<<" ";
            res-=v[i]; 
        }
    }
    return 0;
}

有依赖的背包问题

题目链接

图解：

在这里插入图片描述

代码实现：

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=110;
int f[N][N],v[N],w[N],h[N],ne[N],e[N],idx;
int n,m;
void add(int a,int b)//a是b的父节点
{
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

void dfs(int u)//因为u是根节点,所以u是必选的
{
    for(int i=h[u];i!=-1;i=ne[i])//枚举子树
    {
        int son=e[i];//记录子树的根节点
        dfs(e[i]);//因为dfs是自下而上的,所以需要从下到上计算

        for(int j=m-v[u];j>=0;j--)//因为u是该树的根节点,所以必选,预留出u的空间
         for(int k=0;k<=j;k++)//枚举该子树分配到的体积
         f[u][j]=max(f[u][j],f[u][j-k]+f[son][k]);//加上该子树的值
    }
    //把物品u加进去,因为是根节点
    for(int i=m;i>=v[u];i--) f[u][i]=f[u][i-v[u]]+w[u];
    for(int i=0;i<v[u];i++) f[u][i]=0;//如果无法容纳物品u,那他的价值为0;
}
int main()
{
    memset(h,-1,sizeof(h));

    scanf("%d%d",&n,&m);

    int anser;
    for(int i=1;i<=n;i++)
    {
        int p;
        scanf("%d%d%d",&v[i],&w[i],&p);

        if(p==-1) anser=i;//寻找出祖宗节点
        else add(p,i);
    }

    dfs(anser);

    printf("%d",f[anser][m]);

    return 0;
}

Galactus_hao

关注

7
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
DP背包问题及优化详解（全）

背包问题01背包问题原题链接抽象题目：有nnn件物品和一个容量为vvv的背包。第i件物品的体积是v[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。特点：每个物品最多选1次。二维数组实现方式：状态转换方程：dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i])状态转换方程解释：对于第i个物品有两种情况：1.不选第i个物品时：dp[i][j]=dp[i-1][j]2.选择第i个物品时：dp[i][j]=
复制链接

扫一扫