acwing算法高课背包dp

最新推荐文章于 2025-11-24 17:02:03 发布

原创最新推荐文章于 2025-11-24 17:02:03 发布 · 304 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #算法

acwing 专栏收录该内容

36 篇文章

订阅专栏

本文详细介绍了动态规划在解决01背包、完全背包、多重背包、分组背包、混合背包以及依赖背包问题中的应用。通过实例展示了如何转换和优化问题，实现背包问题的高效求解，并给出了具体代码实现。

文章目录

- 背包问题

背包问题

01 背包

for(int i = 1; i <= n; i ++)
{
	cin >> v >> w;
	for(int j = m; j >= v; j --)//体积从大到小，这样物品i仅使用了一次
		dp[j] = max(dp[j], dp[j - v] + w;
}
cout << dp[m];

完全背包

for(int i = 1; i <= n; i ++)
{
	cin >> v >> w;
	for(int j = v ; j <= m; j ++)//体积从小到大，这样物品i使用多次
		dp[j] = max(dp[j], dp[j - v] + w;
}
cout << dp[m]

多重背包

多重背包二进制优化

利用二进制转化为01背包问题

for(int i = 1; i <= n; i ++)
    {
        int v, w, s;
        cin >> v >> w >> s;
        for(int k = 1; k <= s; k = k * 2)//将s个物品转化
        {
            node x;
            x.w = w * k;
            x.v = v * k;
            s -= k;
            g.push_back(x);
        }
        if(s != 0)
        {
            node x;
            x.w = w * s;
            x.v = v * s;
            g.push_back(x);
        }
    }
    for(int i = 1; i <= g.size(); i ++)
    {
        auto x = g[i-1];
        for(int j = m; j >= x.v; j --)
        {
            dp[j] = max(dp[j], dp[j-x.v] + x.w);
        }
    }
    cout << dp[m];

分组背包

 
    for(int i = 1; i <= n; i ++)
    {
        for(int j = m; j >= 0; j --)
        {
            for(int k = 0; k < g[i].size(); k ++)//决策在第三重循环
            {
                auto x = g[i][k];
                if(j >= x.first)
                dp[j] = max(dp[j], dp[j - x.first] + x.second);
            }
        }
    }

混合背包

根据不同种类，第二重循环不同

背包方案数

for(int i = 0; i <= m; i ++)cnt[i] = 1;//初始化方案数
for(int i = 1; i <= n; i ++)
{
    int v, w;
    cin >> v >> w;
    for(int j = m; j >= v; j --)
    {
       int value = dp[j - v] + w;
       if(value > dp[j])//当前方案更优
       {
           cnt[j] = cnt[j - v];
           dp[j] = value; 
       }else if(value == dp[j])//两种方案相同
           cnt[j] = (cnt[j] + cnt[j - v]) % mod;
    }
}
cout << cnt[m];

依赖背包

请添加图片描述

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 110;
int n,m;
int h[N],e[N],ne[N],idx;
/*h数组是邻接表的头它的下表是当前节点的标号，值是当前结点第一条边的编号（其实是最后加入的那一条边），e数组是边的集合，它的下标是当前边的编号，数值是当前边的终点；
ne是nextedge，如果ne是-1表示当前结点没有下一条边，ne的下标是当前边的编号，数值是当前结点的下一条边的编号，idx用于保存每一条边的上一条边的编号。
这样我们就知道了当前结点的第一条边是几，这个边的终点是那个结点，该节点的下一条边编号是几，那么邻接表就完成了
*/ 
int v[N],w[N],f[N][N]; 

void add(int a,int b){
    e[idx] = b,ne[idx] = h[a],h[a] = idx++;//该方法同于向有向图中加入一条边，这条边的起点是a，终点是b，加入的这条边编号为idx

}
void dfs(int u){
    for(int i = h[u];i!=-1;i = ne[i]){//对当前结点的边进行遍历 
        int son = e[i];//e数组的值是当前边的终点，即儿子结点 
        dfs(son); 
        for(int j = m-v[u];j>=0;j--){
        //遍历背包的容积，因为我们是要遍历其子节点，所以当前节点我们是默认选择的。
        //这个时候当前结点我们看成是分组背包中的一个组，子节点的每一种选择我们都看作是组内一种物品，所以是从大到小遍历。
        //我们每一次都默认选择当前结点，因为到最后根节点是必选的。 
            for(int k = 0;k<=j;k++){//去遍历子节点的组合 
                f[u][j] = max(f[u][j],f[u][j-k]+f[son][k]);
            }
        }
    }
    //加上刚刚默认选择的父节点价值
    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;
    }
}

int main(){
    memset(h,-1,sizeof h);
    cin>>n>>m;
    int root;
    for(int i = 1;i<=n;i++){
        int p;
        cin>>v[i]>>w[i]>>p;
        if(p==-1){
            root = i;
        }else{
            add(p,i);//如果不是根节点就加入邻接表,其中p是该节点的父节点，i是当前是第几个节点
        }
    }
    dfs(root);
    cout<<f[root][m]<<endl;
    return 0;
}

背包方案

for(int i = n ;i >= 1; i --)//倒序求解，方便求最小字典序
{
     for(int j = m; j >= 0; j --)//一定要更新到0，不然状态不全
     {
         dp[i][j] = dp[i + 1][j];
         if(j >= v[i])
         dp[i][j] = max(dp[i][j], dp[i+1][j - v[i]] + w[i]);
     }
 }
 int vol = m;
 for(int i = 1; i <= n; i ++)
 {
     if((dp[i][vol] == dp[i+1][vol - v[i]] + w[i])&&(vol >= v[i]))//物品1可以要一定要。
     {
        printf("%d ",i);
        vol -= v[i];
     }
 }