背包九讲(动态规划)

已于 2024-08-16 10:49:55 修改
阅读量160 收藏 3
点赞数 7
文章标签： 算法 c++
于 2024-08-12 20:00:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80805258/article/details/141140571
版权

文章目录

闫氏DP分析法

在这里插入图片描述

DP问题主要是靠经验的，所以要多加练习总结

1.01背包问题

题目链接

在这里插入图片描述

f[i][j]表示只看前i个物品，总体积是j的情况下，总价值最大是多少

result=max(f[n][0v])

f[i][j];

1.不选第i个物品，f[i][j]=f[i-1][j];

2.选第i个物品，f[i][j]=f[i-1][j-v[i]]+w[i];

朴素版代码

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N][N],v[N],w[N];
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		cin>>v[i]>>w[i];
	for(int i=1;i<=n;i++)//默认f[0][0]为0
	for(int j=0;j<=m;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]);//有i无i作比较
			
	 } 
	int res=0;
	for(int i=0;i<=m;i++)
		res=max(res,f[n][i]);
	cout<<res<<endl;//直接输出f[n[[m]也行；
	return 0;
 }

优化版

很容易想到吧if判定条件放在循环的时候，可以把数组f变为一维的，因为i=i-1，可以知道，都是从上一个状态转移过来的但是j 不是上一个转移的（本来i=i-1,即j对于的是上一个i,现在把i去掉)，j 可以从大到小，这样就上从上一个转移过来的

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N],v[N],w[N];
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--)//从大到小
			f[j]=max(f[j],f[j-v[i]]+w[i]);
	cout<<f[m]<<endl;
	return 0;
 }

一个循环

其实就是简单变形

#include<iostream>
using namespace std;
int f[10000];
int main()
{
	int N,V;
	cin>>N>>V;
	for(int i=1;i<=N;i++)
	{
		int v,w;
		cin>>v>>w;
		for(int j=V;j>=v;j--)
			f[j]=max(f[j],f[j-v]+w);
		
	}
	cout<<f[V]<<"\n";
	return 0;
}

2.完全背包

题目链接
与01背包的差别就是这个可以无限选
在这里插入图片描述
前i-1项已经定型，第i项选k个i ，选第i个的时候空间还有v-k*i;
可以得出f[i][j]=f[i-1][j],f[i][j]=f[i-1][j-v]+w
推导出
f[i][j] = max(f[i-1][j],f[i-1][j-v]+w,f[i-1][j-2v]+2w,…)
f[i][j-v] = max(f[i-1][j-v],f[i-1][j-2v]+w,f[i-1][j-3v]+2w…)
第一个式子的第2项和第二个式子的第一项作比较，发现只相差一个w
推导为f[i,j] = max(f[i-1][j],f[i][j-v]+w);

朴素代码

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N][N],v[N],w[N];
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=0;j<=m;j++)
	{
		f[i][j]=f[i-1][j];
		if(j>=v[i])
			f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);//
			
	 } 
	cout<<f[n][m]<<endl;
	return 0;
 }

优化代码

优化思路：先把if判断消去，而且i和j是等价的，所以数组f可以直接变为一维

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N],v[N],w[N];
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=v[i];j<=m;j++)
			f[j]=max(f[j],f[j-v[i]]+w[i]);
	cout<<f[m]<<endl;
	return 0;
 }

一个循环

#include<iostream>
using namespace std;
int f[10000];
int main()
{
	int N,V;
	cin>>N>>V;
	for(int i=1;i<=N;i++)
	{
		int v,w;
		cin>>v>>w;
		for(int j=v;j<=V;j++)
			f[j]=max(f[j],f[j-v]+w);
		
	}
	cout<<f[V]<<"\n";
	return 0;
}

3.多重背包 1

题目链接
在这里插入图片描述
每个物品随便选，可以想到第i件物品选s[i]个依次比较
可以得到公式**f[i][j]=max(f[i][j],f[i-1][j-v[i]k]+w[i]k)

朴素代码

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int n,m;
int f[N][N],v[N],w[N],s[N];
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		cin>>v[i]>>w[i]>>s[i];
	for(int i=1;i<=n;i++)
		for(int j=0;j<=m;j++)
			for(int k=0;k<=s[i]&&k*v[i]<=j;k++)
				f[i][j]=max(f[i][j],f[i-1][j-v[i]*k]+w[i]*k);
	cout<<f[n][m]<<endl;
	return 0;
 }

4.多重背包2

题目链接
其实就是数据变大的多重背包1

优化代码(背包1的优化)

倍增法

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=25000;
int n,m;int v[N],w[N]; int f[N];
int main()
{
	 cin>>n>>m;
	 int cnt=0;
	 for(int i=1;i<=n;i++)
	 {
	 	int a,b,s;
	 	cin>>a>>b>>s;
	 	int k=1;
	 	while(k<=s)
	 	{
	 		cnt++;
	 		v[cnt]=a*k;
	 		w[cnt]=b*k;
	 		s-=k;
	 		k*=2;
		}
		if(s>0)
		{
			cnt++;
			v[cnt]=a*s;
			w[cnt]=b*s;
		 } 
	 }
	 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]);
	cout<<f[m]<<endl;
	return 0;
}

优化代码(背包1的优化)

单调队列，思路和上面代码一样，用容器和结构体，但是比上面的慢

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

5.多重背包3

题目链接

朴素代码

其实就是多重背包的终极优化

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=20020;
int n,m,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]<<'\n';
	return 0;
}

6.混合背包

题目链接
混合背包就是把01背包，完全背包，多重背包组合起来，判断一下不同情况就行

朴素代码

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 1111;
int n, m, f[N];
struct Thing 
{
    int kind;
    int v, w;
};
vector<Thing> things;
int main() 
{
    cin >> n >> m;
    for (int i = 0; i < n; i++) 
    {
        int v, w, s;
        cin >> v >> w >> s;
        if (s < 0)
         {
            things.push_back({-1, v, w});
        } 
        else if (s == 0) 
        {
            things.push_back({0, v, w});//判断不同情况入栈
        } 
        else //多重背包，拆分为多个01背包
        {
            for (int k = 1; k <= s; k *= 2) 
            {
                s -= k;
                things.push_back({-1, v * k, w * k});
            }
            if(s>0)things.push_back({-1, v * s, w * s});//最后剩余的
        }
    }
    for (const auto& thing : things) //赋值
    {
        if (thing.kind < 0) 
        {
            for (int j = m; j >= thing.v; j--) 
            {
                f[j] = max(f[j], f[j - thing.v] + thing.w);//01背包求最大值
            }
        } 
        else 
        {
            for (int j = thing.v; j <= m; j++) 
            {
                f[j] = max(f[j], f[j - thing.v] + thing.w);//多重背包求最大值
            }
        }
    }
    cout << f[m] << '\n';
    return 0;
}

7.二维费用的背包问题

题目链接
其实和01背包一样，就加了一个限制条件(重量）
就这个核心公式： f[i][j1][j2] = max (f[i][j1][j2],f[i - 1][j1 - w1][j2 - w2] + v)

朴素代码

#include <iostream>
using namespace std;
const int N = 110;
int n,m1,m2;
int f[1010][N][N];
int main () {
    cin >> n >> m1 >> m2;
    for (int i = 1;i <= n;i++) {
        int w1,w2,v;
        cin >> w1 >> w2 >> v;
        for (int j1 = m1;j1 >= 0;j1--) {
            for (int j2 = m2;j2 >= 0;j2--) {
                f[i][j1][j2] = f[i - 1][j1][j2];
                if (j1 >= w1 && j2 >= w2) 
                	f[i][j1][j2] = max (f[i][j1][j2],f[i - 1][j1 - w1][j2 - w2] + v);
            }
        }
    }
    cout << f[n][m1][m2] << endl;
    return 0;
}

优化代码

减少不必要循环

#include<iostream>
#include<algorithm>
using namespace std;
const int N=111;
int n,v,m,f[N][N];
int main()
{
	cin>>n>>v>>m;
	for(int i=0;i<n;i++)
	{
		int a,b,c;
		cin>>a>>b>>c;
		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]+c);
	}
	cout<<f[v][m]<<'\n';
	return 0;
}

8.分组背包问题

题目链接
其实就是多个01背包，每一组可以选也可以不选，就是第i组选第k个
在这里插入图片描述
式子1：f[i-1][j]
式子2：f[i-1][j-v[i][k]]+w[i][k]
即f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);

朴素代码

#include<iostream>
#include<algorithm>
using namespace std;
const int N=191;
int n,m,v[N][N],w[N][N],s[N],f[N];
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		cin>>s[i];
		for(int j=0;j<s[i];j++)
			cin>>v[i][j]>>w[i][j];
	}
	for(int i=1;i<=n;i++)
		for(int j=m;j>=0;j--)
			for(int k=0;k<s[i];k++)
			    if(v[i][k]<=j)
			    	f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
	cout<<f[m]<<endl;
	return 0;
}

朴素代码

其实和上面前一样

#include<iostream>
#include<algorithm>
using namespace std;
const int N=190;
int n,m,v[N],w[N],s,f[N];
int main()
{
	cin>>n>>m;
	for(int i=0;i<n;i++)
	{
		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(v[k]<=j)
				f[j]=max(f[j],f[j-v[k]]+w[k]);
	}
	cout<<f[m]<<endl;
	return 0;
}

9.有依赖的背包问题

题目链接
树形DP和背包问题的结合

朴素代码

#include <iostream>
#include <vector>

using namespace std;

int f[110][110]; // f[x][v] 表示选择以 x 为子树的物品，在容量不超过 v 时所获得的最大价值
vector<int> g[110];//vector<int> g[110] 用于构建树的邻接表，存储每个节点的子节点。
int v[110], w[110];//v[110] 数组存储每个物品（节点）的体积，w[110] 数组存储每个物品的价值。
int n, m, root;

int dfs(int x, int m) 
{
    for (int i = v[x]; i <= m; i++) f[x][i] = w[x]; // 点 x 必须选，所以初始化 f[x][v[x] ~ m] = w[x]
    for (int i = 0; i < g[x].size(); i++) 
    {
        int y = g[x][i];
        dfs(y, m - v[x]);//，对于每个子节点 y ，递归调用 dfs(y, m - v[x]) ，即计算子节点在剩余容量下的最大价值。
       
       //两层循环更新当前节点 x 在不同容量 j的最大价值。内层循环枚举分配给子节点 y 的容量 k ，通过比较更新 f[x][j] 的值。
        for (int j = m; j >= v[x]; j--) 
        { // j 的范围为 v[x] ~ m, 小于 v[x] 无法选择以 x 为子树的物品
            for (int k = 0; k <= j - v[x]; k++) 
            { // 分给子树 y 的空间不能大于 j - v[x], 不然都无法选根物品 x
                if (f[x][j - k] + f[y][k] > f[x][j]) 
                { 
                    f[x][j] = f[x][j - k] + f[y][k];
                }
            }
        }
    }
    return f[x][m];
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) 
    {
        int ff;
        cin >> v[i] >> w[i] >> ff;
        if (ff == -1)
            root = i;
        else
            g[ff].push_back(i);
    }
    cout << dfs(root, m);
    return 0;
}

10.背包问题求方案数

题目链接
01背包换了一种问法，就是找到最大值之后确定有几个最大值

朴素代码

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1111,mod=1000000007,INF=1000000;
int n,m;
int f[N],g[N];
int main()
{
	cin>>n>>m;
	g[0]=1;
	for(int i=1;i<=m;i++)
		f[i]= -INF;
	for(int i=0;i<n;i++)
	{
		int v,w;
		cin>>v>>w;
		for(int j=m;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;//取模
			f[j]=t;//最优解
			g[j]=s;//方案数
		}
	}
	int maxw = 0;
	for(int i = 0;i <= m;i ++)
	maxw=max(maxw,f[i]);//求最优解，体积不一定用完
	int res=0;
	for(int i = 0;i <= m;i ++)
	if(maxw==f[i])//所有最优解方案
	{
		res+=g[i];
		if(res>=mod) res -= mod;//取模
	}
	cout<<res<<'\n';
	return 0;
}

11.背包问题求具体方案

题目链接
在这里插入图片描述
和01完全一样，就是找一下具体是选哪一个，不过要注意一下字典序最小，正常求法是最大，所以逆过来

朴素代码

#include<iostream>
#include<algorithm>

using namespace std;
const int N=1111;
int n ,m,f[N][N],v[N],w[N];
int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		cin>>v[i]>>w[i];
	for(int i=n;i>=0;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][j],f[i+1][j-v[i]]+w[i]);
		}
	int i=1,j=m;
	while(i<=n)
	{
		if(j>=v[i]&&f[i+1][j-v[i]]+w[i]>=f[i+1][j])//右边可以取到最大值
		{
			cout<<i<<' ';
			j-=v[i];
			i++;
		}
		else i++;//不能选择第i个物品（左边集合）
	}
	return 0;
}
库日天30
关注
[动态规划] 《背包九讲》阅读笔记
OI - IceCab
07-19 609
1.01背包 题目与问题解决 有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。 过程 ZeroOnePack，表示处理一件01背包中的物品，两个参数cost、weight分别表明这件物品的费用和价值。 不同问题的初始化 有的题目要求“恰好装满背包”时的最优解，有的题目则并没有要求必须把背包装满。...
背包九讲动态规划入门
07-28
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，...
背包九讲——全篇详细理解与代码实现
热门推荐
良月澪二的博客
12-04 15万+
dd_engi背包九讲的个人整理，包含代码例题及个人理解
动态规划（背包九讲 一）
2301_80304432的博客
08-13 848
超详细的讲解，很适合初学者
动态规划-背包九讲(常见背包问题整理)
浪里小白龙nbw的博客
09-10 1168
本文整理了常见的各种背包类型问题，从问题出发详解各种背包问题，代码配有详细注释。建议收藏！
背包九讲（灵魂版）
2301_81692739的博客
08-15 838
多重背包单调队列优化、有依赖的背包问题不明白？dp思想模模糊糊？快进来学习吧
【动态规划】之背包问题九讲
Genevieve_xiao的博客
08-06 1178
背包问题01背包01背包朴素01背包优化完全背包完全背包朴素完全背包一级优化完全背包二级优化多重背包多重背包朴素多重背包二进制优化多重背包单调队列优化分组背包混合背包二维费用的背包01背包01背包 01背包 题目描述 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N
背包九讲（动态规划）
2401_84027054的博客
08-13 777
原因：f[i] [j]是从上一轮i-1的状态得来的，f[i] [j]和f[i-1] [j]并不相等，优化到一维后，如果我们还是正序，那么本应该是第i-1的状态用来更新的却是第i轮的状态。01背包的动态转移方程是：f[i] [j]=max(f[i-1] [j],f[i-1] [j-v[i]]+w[i]);
day06 动态规划 背包九讲
weixin_58826989的博客
04-29 137
动态规划 背包九讲 状压DP 树形DP 数位DP
动态规划（背包九讲 二）
2301_80304432的博客
08-18 813
背包dp完结篇，超详细
动态规划（背包九讲）
iwant_的博客
08-06 526
对于背包问题的一个系统性的介绍，内容比较详细，并且还描述了分析方法，比较容易理解。
动态规划之背包九讲崔添翼版本
10-05
"动态规划之背包九讲崔添翼版本"是一份深入讲解背包问题的资料，其中涵盖了动态规划在背包问题中的应用。 背包问题是一个经典的优化问题，描述如下：假设我们有N件物品，每件物品有自己的重量Ci1和对应的收益Wi。...
背包九讲完整版.pdf
10-27
"背包九讲完整版.pdf" 本资源为一份关于动态规划的详细指南，涵盖了背包问题的九个方面，包括基本的背包问题、完全背包问题、多重背包问题、混合三种背包问题、二维费用的背包问题、分组的背包问题、有依赖的背包...
动态规划（DP）-背包问题算法详解背包九讲
01-12
动态规划（DP）——背包问题算法详解[背包九讲]
dd大牛的背包九讲 动态规划
08-04
《背包九讲》是DD大牛的一篇经典论文，主要探讨了动态规划在解决背包问题中的应用。动态规划（Dynamic Programming，简称DP）是一种优化技术，通过将复杂问题分解为子问题来逐步求解，特别适合处理具有重叠子问题和...
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1250
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
最新发布
2301_80161204的博客
09-27 439
25[0, 105]
189. 轮转数组（C++）
weixin_45813121的博客
09-25 449
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
时间序列分析算法
qq_58353992的博客
09-24 923
通信领域：网络流量预测、服务器负载预测等。
动态规划解析：背包问题九讲
"《背包问题九讲》是dd_engi关于动态规划中背包问题的一系列教程，涵盖了01背包、完全背包、多重背包等不同类型的背包问题，以及这些问题的变体和扩展。教程由原作者在不同时间进行了多次修订和完善，旨在深入探讨...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值