ZPP试图掌握DP

自己写的笔记，不建议其他人参考学习

不自量力警告

1.1数字三角形模型

说白了，就是数塔，简单粗暴

在此基础上，我们很容易就可以 想出来它的进阶版本

同样简单无脑

双重for循环再配上，简单的动态转移方程

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

现在我们升级问题

NOIP2000]方格取数

题意大概就是方形数塔，连续跑两次求和的最大值，两次取的数字不能重复计入

错误思路：

第一反应是 跑两遍

随即就意识到了实现的复杂性

由于动态规划跑了一次并没有追溯路径，所以第二次并不知道哪些数字还存在

随即可以想到使用四维dp，利用四重for循环，换汤不换药

	for(int i=1;i<=n;i++)
	for(int j=1;j<=n;j++)
	for(int k=1;k<=n;k++)
	for(int l=1;l<=n;l++)
	{
		dp[i][j][k][l]=max(max(dp[i-1][j][k-1][l],dp[i][j-1][k][l-1]),max(dp[i][j-1][k-1][l],dp[i-1][j][k][l-1]))+mp[i][j]+mp[k][l];
		if(i==k && j==l)
		dp[i][j][k][l]-=mp[i][j];
	}

为了提高运算效率

我们将其优化，想象两点同时移动，k为任一坐标位置点的和

	for(int k=2;k<=2*n;k++)
	for(int i1=1;i1<=n;i1++)
	for(int i2=1;i2<=n;i2++)
	{
		int j1=k-i1,j2=k-i2;
		if(j1>=1 && j1<=n && j2>=1 && j2<=n)
		{
			dp[k][i1][i2]=max(max(dp[k-1][i1][i2],dp[k-1][i1-1][i2]),max(dp[k-1][i1][i2-1],dp[k-1][i1-1][i2-1]))+mp[i1][j1];
			if(i1!=i2)
			dp[k][i1][i2]+=mp[i2][j2];
		}
	}

若将问题再次升级，将方格取数变为跑K次

最小费用流

1.2最长上升子序列模型（LIS)

长度为N的序列，单调递增的子序列长度最长是多少

动态规划(O(n^2))

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+7;
int a[maxn],dp[maxn];   //dp[i]指以a[i]结尾的LIS长度 
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	for(int i=0;i<n;i++)
	{
        dp[i]=1;
		for(int j=0;j<i;j++)
		{
			if(a[i]>a[j])
			{
				dp[i]=max(dp[i],dp[j]+1);
			}
		 } 
	}
	printf("%d\n",dp[n-1]);
}

贪心+二分(O(NlogN))

#include<iostream>
#include<algorithm>
#define N 100009
using namespace std;
int f[N], a[N];//f[i]为长度为i的LIS结尾元素的最小值
int n;
int find(int l, int r, int x) //find函数用来查找l-r范围内第一个大于x数字的位置
{
	while (l < r) 
	{
		int mid = (l + r) / 2;
		if (f[mid] < x) 
		{
			l = mid + 1;
		} else 
		{
			r = mid;
		}
	}
	return l;
}
int lis() 
{
	int len = 0;
	for (int i = 0; i < n; i++) 
	{
		int k=find(0,len,a[i]);
		f[k] = a[i];
		if (k == len) 
		{
			len++;
		}
	}
	return len;
}
int main() 
{
	scanf("%d", &n);
	for (int i = 0; i < n; i++) 
	{
		scanf("%d",&a[i]);
	}
	printf("%d\n", lis());
	return 0;
}

使用lower_bound的简单写法

	int len=0;
	for(int i=1;i<=n;i++)
	{
		int k=lower_bound(f,f+len,a[i])-f;
		f[k]=a[i];
		if(k==len)
		{
			len++;
		}	
	}
	printf("%d\n",len);

f[i]为长度为i的LIS结尾元素的最小值，对于一个上升子序列，显然其结尾元素越小，越有利于在后面接其他的元素，也就越可能变得更长。

对于每一个a [ i ]，如果a [ i ]能接到 LIS 后面，就接上去；否则，就用 a [ i ] 取更新f 数组。具体方法是，在f数组中找到第一个大于等于a [ i ]的元素low [ j ]，用a [ i ]去更新 low [ j ]。

	有以下序列A[ ] = 3 1 2 6 4 5 10 7，求LIS长度。

　　我们定义一个B[ i ]来储存可能的排序序列，len 为LIS长度。我们依次把A[ i ]有序地放进B[ i ]里。

	A[1] = 3，把3放进B[1]，此时B[1] = 3，此时len = 1，最小末尾是3

　　A[2] = 1，因为1比3小，所以可以把B[1]中的3替换为1，此时B[1] = 1，此时len = 1，最小末尾是1

　　A[3] = 2，2大于1，就把2放进B[2] = 2，此时B[ ]={1,2}，len = 2

　　同理，A[4]=6，把6放进B[3] = 6，B[ ]={1,2,6}，len = 3

　　A[5]=4，4在2和6之间，比6小，可以把B[3]替换为4，B[ ] = {1,2,4}，len = 3

　　A[6] = 5，B[4] = 5，B[ ] = {1,2,4,5}，len = 4 

　　A[7] = 10，B[5] = 10，B[ ] = {1,2,4,5,10}，len = 5

　　A[8] = 7，7在5和10之间，比10小，可以把B[5]替换为7，B[ ] = {1,2,4,5,7}，len = 5

注意！注意！注意！

B[]的长度仅能代表LIS的大小，而B[]并不一定是正确的最长上升子序列

有以下序列A[ ] = 1 4 7 2 5 9 10 3，求LIS长度。  有以下序列A[ ] = 1 4 7 2 5 9 10 3，求LIS长度.

   A[1] = 1，把1放进B[1]，此时B[1] = 1，B[ ] = {1}，len = 1

   A[2] = 4，把4放进B[2]，此时B[2] = 4，B[ ] = {1,4}，len = 2

   A[3] = 7，把7放进B[3]，此时B[3] = 7，B[ ] = {1,4,7}，len = 3

   A[4] = 2，因为2比4小，所以把B[2]中的4替换为2，此时B[ ] = {1,2,7}，len = 3

   A[5] = 5，因为5比7小，所以把B[3]中的7替换为5，此时B[ ] = {1,2,5}，len = 3

   A[6] = 9，把9放进B[4]，此时B[4] = 9，B[ ] = {1,2,5,9}，len = 4

   A[7] = 10，把10放进B[5]，此时B[5] = 10，B[ ] = {1,2,5,9,10}，len = 5

   A[8] = 3，因为3比5小，所以把B[3]中的5替换为3，此时B[ ] = {1,2,3,9,10}，len = 5

[合唱队形]([NOIP2004 提高组] 合唱队形)模型

即求一段先升后降的最长序列

正着跑一遍，再倒着跑一遍，观察拼接起来的最大值

	for(int i=1;i<=n;i++)
	{
		dp1[i]=1;
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j])
			{
				dp1[i]=max(dp1[i],dp1[j]+1);
			}
		}
	}
	for(int i=n;i>=1;i--)
	{
		dp2[i]=1;
		for(int j=n;j>i;j--)
		{
			if(a[i]>a[j])
			{
				dp2[i]=max(dp2[i],dp2[j]+1);
			}
		}
	}
	int res=0;
	for(int i=1;i<=n;i++)
	{
		res=max(res,dp1[i]+dp2[i]-1);
	}

[友好城市](P2782 友好城市 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn))模型

一条河，两边各n个城市，有桥梁一一对应连接guanxi

怎么连接的数量最大并且没有桥梁交叉

如图

对于这个模型，我们将一侧排好序后，直接判断另一侧城市坐标的LIS即可

const int maxn=2*1e5+7;
pair<int ,int>p[maxn];
int dp[maxn];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d",&p[i].first,&p[i].second);
	}
	sort(p+1,p+n+1);
	int ans=0;
	for(int i=1;i<=n;i++)
	{
		dp[i]=1;
		for(int j=1;j<i;j++)
		{
			if(p[i].second>p[j].second)
			{
				dp[i]=max(dp[i],dp[j]+1);
			}
		}
		ans=max(ans,dp[i]);
	}
	printf("%d\n",ans);
}

**[导弹拦截]([P1020 NOIP1999 普及组] 导弹拦截 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn))**模型

一组数字，求最少可以用多少上升序列将其完全覆盖

例如

389 207 155 300 299 170 158 65

用两组即可实现

最优解为

398 300 299 170 158 65

207 155

同时也可以使用贪心思想，对于每一组序列，我们希望其末尾数字越大越好，因此对于新的数字加入，我们可以将其安排在比其大且相差最小的序列组后

贪心解法为

389 207 105 65

300 299 170 158

最后我们发现：贪心法和最优解，可以互相转换得到，并不影响最终结果

这与LIS的二分贪心解法有异曲同工之妙

这是dilworth定理

[导弹防御系统](187. 导弹防御系统 - AcWing题库)

上一题的plus版本，题意是现在有两种类型的导弹，一种上升，一种下降，怎样最少实现全覆盖？

对于该题，使用暴力dfs搭配贪心求解的方法来解决

每个数我们都用dfs的方法将其放入尝试一遍，最后暴力搜索得到的最小值即为我们的答案

int a[55],up[55],down[55];int n,ans;
void dfs(int nn,int u,int d)//第nn个数，上升子序列数，下降子序列数
{
	if(u+d>=ans)//这里最开始写的>，然后tle了
	return;
	if(nn==n+1)
	{
	    ans=min(ans,u+d);return;
	}
	//将该数放入上升序列
	int cnt=0;
	while(cnt<u && a[nn]<up[cnt])
	cnt++;
	int t=up[cnt];
	up[cnt]=a[nn];
	if(cnt<u)
	dfs(nn+1,u,d);
	else
	dfs(nn+1,u+1,d);
	up[cnt]=t;
	//放入下降序列
	cnt=0;
	while(cnt<d && a[nn]>down[cnt])
	cnt++;
	t=down[cnt];
	down[cnt]=a[nn];
	if(cnt<d)
	dfs(nn+1,u,d);
	else
	dfs(nn+1,u,d+1);
	down[cnt]=t;
} 
int main()
{
	while(cin>>n && n)
	{
		ans=n;
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
		}
		dfs(1,0,0);
		printf("%d\n",ans);
	}
}

[最长公共上升子序列](272. 最长公共上升子序列 - AcWing题库)

规定：dp[i][j]是 第一个序列a[]的前i个字母，和第二个序列b[]的前j个字母，并且以b[j]结尾的最长公共子序列长度

对于dp[i][j]，考虑是否以a[i]结尾

1.不以a[i]结尾

则a[i]不参与最长公共子序列的构建结果，可以去掉a[i]，那么结果等同dp[i-1][j]

2.以a[i]结尾

由公共子序列可知，a[i]==b[i],则我们可以将问题转化为dp[i][j]=dp[i-1][j-1]+1

int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	scanf("%d",&a[i]);
	for(int i=1;i<=n;i++)
	scanf("%d",&b[i]);
	int res=0;
	for(int i=1;i<=n;i++)
	{
		int maxv=1;
		for(int j=1;j<=n;j++)
		{
			dp[i][j]=dp[i-1][j];
			if(a[i]==b[j])
			dp[i][j]=max(dp[i][j],maxv+1);
			if(b[j]<a[i])
			maxv=max(maxv,dp[i][j]+1);
			res=max(res,dp[i][j]);
		}
	}
	printf("%d",res);
}

1.3背包问题

01背包问题

for(int i=2;i<=n;i++)
for(int j=c;j>=power[i];j--)
dp[j]=max(dp[j],dp[j-power[i]]+val[i]);

完全背包问题

for(int i=1;i<=n;i++)
{
	for(int j=w[i];j<=m;j++)
	{
		dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
	}
}

多重背包问题

**不优化 **

其实就是把它当成排列组合版的01背包

#include<bits/stdc++.h>
using namespace std;
int w[1005],val[1005],dp[1005],s[1005];
int main()
{
	int n,v;
	scanf("%d%d",&n,&v);
	for(int i=0;i<n;i++)
	{
		scanf("%d%d%d",&w[i],&val[i],&s[i]);
	}
	for(int i=0;i<n;i++)
	{
		for(int j=v;j>=0;j--)
		{
			for(int k=0;k<=s[i]&&k*w[i]<=j;k++)
			dp[j]=max(dp[j],dp[j-k*w[i]]+k*val[i]);
		}
	}
	printf("%d\n",dp[v]); 
}

二进制优化

即把一个物品可拿的数量拆分为 2的幂次方大小的集合

比如11拆分为 1 2 4 4

观察可以发现，这种拆分方法可以组合出小于该数字的全部情况，同时节约了便利的过程

#include<bits/stdc++.h>
using namespace std;
int v[100005],w[100005],cnt=1,dp[100005];
int main()
{
	int n,V;
	scanf("%d%d",&n,&V);
	int a,b,c;
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d%d",&a,&b,&c);
		for(int j=1;j<=c;j*=2)
		{
			v[cnt]=a*j;
			w[cnt++]=b*j;
			c-=j;
		}
		if(c)
		{
			v[cnt]=c*a;
			w[cnt++]=b*c;
		}
	}
	for(int i=1;i<cnt;i++)
	{
		for(int j=V;j>=0;j--)
		{
			if(j>=v[i])
			{
				dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
			} 
		}
	}
	printf("%d\n",dp[V]);
}

单调队列优化

首先要知道啥叫单调队列

经典模板滑动窗口

在单调队列中，每回合输出队首（即最大/最小值）

当队首的位置小于i-k时，k++（即队首已经离开窗口覆盖范围，将其从队列弹出）

同时不断更新队尾，当一个新的元素加入时，如果该元素比它前方的数字更大/小，那么将它前面的数字弹出后再将新元素插入。因为新元素比弹出的元素更加大/小，说明其前面的元素没有成为最大/最小的可能，直接弹出即可

const int maxn=1e6+7;
int a[maxn],q[maxn];
int main()
{
	int n,k;
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
	}
	int head=1,tail=0;
	for(int i=1;i<=n;i++)
	{
		if(head<=tail && q[head]<=i-k)//如果没head<=tail q[head]里没有值 
		head++;
		while(head<=tail && a[q[tail]]>=a[i])
		tail--;
		q[++tail]=i;
		if(i>=k)
		printf("%d ",a[q[head]]);
	}
	printf("\n");
	head=1,tail=0;
	for(int i=1;i<=n;i++)
	{
		if(head<=tail && q[head]<=i-k)
		head++;
		while(head<=tail && a[q[tail]]<=a[i])
		tail--;
		q[++tail]=i;
		if(i>=k)
		printf("%d ",a[q[head]]);
	}
	printf("\n");
} 

开始使用单调队列进行优化

每类物品的体积为v, 价值为w，个数为s

dp[i][j]=max(dp[i-1][j],dp[i-1][j-v]+w,dp[i-1][j-2*v]+2*w,…,dp[i-1][j-k*v]+k*w)

使用滚动数组，变为

dp[m] = max(dp[m], dp[m-v] + w, dp[m-2*v] + 2*w, dp[m-3*v] + 3*w, …)

接下来，我们把 dp[0] --> dp[m] 写成下面这种形式
dp[0], dp[v], dp[2*v], dp[3*v], … , dp[k*v]
dp[1], dp[v+1], dp[2*v+1], dp[3*v+1], … , dp[k*v+1]
dp[2], dp[v+2], dp[2*v+2], dp[3*v+2], … , dp[k*v+2]
…
dp[j], dp[v+j], dp[2*v+j], dp[3*v+j], … , dp[k*v+j]

显而易见，m 一定等于 k*v + j，其中 0 <= j < v

所以

dp[j] = dp[j]
dp[j+v] = max(dp[j], dp[j+v] - w) + w
dp[j+2v] = max(dp[j], dp[j+v] - w, dp[j+2v] - 2w) + 2w
dp[j+3v] = max(dp[j], dp[j+v] - w, dp[j+2v] - 2w, dp[j+3v] - 3w) + 3w
…
这样，每次入队的值是 dp[j+k*v] - k*w

于是对于dp[j+n*v]我们很容易就发现 可以用单调队列的方法来解决

ll dp[200005],pre[200005],q[200005];
int main()
{
	int N,V;
	scanf("%d%d",&N,&V);
	int v,w,s;
	for(int i=1;i<=N;i++)
	{
		scanf("%d%d%d",&v,&w,&s);
		//复制pre是因为为了拿余数，下层循环需要正着跑，所以拿pre记录上一层 
		memcpy(pre,dp,sizeof(dp));
		for(int j=0;j<v;j++)
		{
			int head=0,tail=-1;
			for(int k=j;k<=V;k+=v)
			{
				if(head<=tail && k-s*v>q[head])
				head++;
				while(head<=tail && pre[q[tail]] - (q[tail] - j)/v * w <= pre[k] - (k - j)/v * w)
				tail--;
				if(head<=tail)
				{
				//	dp[k]=max(dp[k],pre[q[head]]-(q[head-j])/v*w+(k-j)/v*w);
					dp[k]=max(dp[k],pre[q[head]]+(k - q[head])/v * w);
				}
				
				q[++tail]=k;
			}
		}
	}
	cout<<dp[V];
}

二维费用的背包问题模型

01背包两个 一个物品两种要求

开个滚动二维数组即可，写法与01背包一致

潜水员模型

考虑为背包装满的模型题，这种背包初始化时，将数组初始化为0x3f，由于dp[0]背包容量为0，什么也不放背包也是装满状态，所以dp[0]=1

const int N=50,M=160;//N,M 取最大取值范围的二倍
int dp[N][M]; 
int main()
{
	memset(dp,0x3f,sizeof(dp));
	dp[0][0]=0;
	int n,m;
	scanf("%d%d",&n,&m);
	int k;
	cin>>k;
	int ans=0x3f3f3f3f;
	while(k--)
	{
		int a,b,c;
		cin>>a>>b>>c;
		for(int i=N-1;i>=a;i--)
		{
			for(int j=M-1;j>=b;j--)
			{
				dp[i][j]=min(dp[i][j],dp[i-a][j-b]+c);
				
			}
		}
	}
	for(int i=n;i<N;i++)
	{
		for(int j=m;j<M;j++)
		ans=min(ans,dp[i][j]);
	}
	cout<<ans;
}

数字组合模型

第一眼看上去像是，装满的背包问题，可是这题要求的不是最大价值，而是总方案数

f[i][j]为前i个物品，装满 j 的方案数

1.不拿第i个物品 f[i-1][j]

2.拿第i个物品 f[i-1][j-v[i]]

所以f[i][j]=f[i-1][j]+f[i-1][j-v[i]]

使用滚动数组

const int maxn=1e6+7;
int f[maxn];
int main()
{
	f[0]=1;
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		int v;
		cin>>v;
		for(int j=m;j>=v;j--)
		f[j]+=f[j-v];
	}
	cout<<f[m];
}

买书模型

数字组合的完全背包版本

可以和完全背包一样，二层for循环倒序即可

int f[maxn];
int m[4]={10,20,50,100}; 
int main()
{
	int n;
	cin>>n;
	f[0]=1;
	for(int i=0;i<4;i++)
	{
		for(int j=m[i];j<=n;j++)
		{
			f[j]+=f[j-m[i]];
		}
	}
	cout<<f[n];
}

货币系统模型

买书模型的实际应用

对于，一种货币，如果比它小的货币可以组成它，则它是多余的

于是我们顺序遍历所有货币的组成情况，没有组成情况的说明必须统计

int a[105],f[25005];
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int n;
		cin>>n;
		for(int i=1;i<=n;i++)
		cin>>a[i];
		sort(a+1,a+n+1);
		int m=a[n];
		memset(f,0,sizeof(f));
		f[0]=1;
		int res=0;
		for(int i=1;i<=n;i++)
		{
			if(f[a[i]]==0)
			res++;
			for(int j=a[i];j<=m;j++)
			{
				f[j]+=f[j-a[i]];
			}
		}
		cout<<res<<endl;
	}
}

背包问题求具体方案

跑一遍二维01背包，随后倒序查看每一个f[i][j]是否可以放进背包里

由于本题要求输出最小字典序

那么需要倒序跑01背包，然后就能正着跑放入背包的物品，就可以得到最小字典序了

int f[1005][1005],v[1005],w[1005];
int main()
{
	int N,V;
	scanf("%d%d",&N,&V);
	for(int i=1;i<=N;i++)
	cin>>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];//非常非常非常重要！即使是选不了也要能保证该位置能拿下其他的物品，而不是0
			if(j>=v[i])
			f[i][j]=max(f[i][j],f[i+1][j-v[i]]+w[i]);
		}
	}
	int j=V;
	for(int i=1;i<=N;i++)
	{
		if(j>=v[i] && f[i][j]==f[i+1][j-v[i]]+w[i])
		{
			j-=v[i];
			printf("%d ",i);
		}
	}
}

分组背包问题

当成多重背包问题写即可

机器分配

多组背包+背包具体方案

比较需要熟练度

int w[20][20],f[20][20];
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			scanf("%d",&w[i][j]);
		}
	}
	for(int i=n;i>=1;i--)
	{
		for(int j=0;j<=m;j++)
		{
			f[i][j]=f[i+1][j];
			for(int k=1;k<=j;k++)
			{
				f[i][j]=max(f[i][j],f[i+1][j-k]+w[i][k]);
			}
		}
	}
	cout<<f[1][m]<<endl;
	int j=m;
	for(int i=1;i<=n;i++)
	{
		for(int k=0;k<=j;k++)
		{
			if(f[i][j]==f[i+1][j-k]+w[i][k])
			{
				j-=k;
				printf("%d %d\n",i,k);
				break;
			}
		}
	}
	
}

金明的预算方案

对于一个主件，有5种选法，选其中一种

啥也不选 单选主件 主件+配件1 主件+配件2 主件+配件1+配件2

直接转化为分组背包问题

麻烦点就在于如何存数据

const int maxn=1e5+7;
int n,m;
int w[61][3],v[61][3],f[maxn];
int main()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		int a,b,c;
		cin>>a>>b>>c;
		if(!c)
		{
			w[i][0]=a,v[i][0]=b;
		}
		else if(w[c][1]==0)
		{
			w[c][1]=a,v[c][1]=b;
		}
		else
		{
			w[c][2]=a,v[c][2]=b;
		}
	}
	for(int i=1;i<=m;i++)
	{
		for(int j=n;j>=w[i][0];j--)
		{
			f[j]=max(f[j],f[j-w[i][0]]+w[i][0]*v[i][0]);
			if(j>=w[i][0]+w[i][1]+w[i][2])
			f[j]=max(f[j],f[j-w[i][0]-w[i][1]-w[i][2]]+w[i][0]*v[i][0]+w[i][1]*v[i][1]+w[i][2]*v[i][2]);
			if(j>=w[i][0]+w[i][1])
			f[j]=max(f[j],f[j-w[i][0]-w[i][1]]+w[i][0]*v[i][0]+w[i][1]*v[i][1]);
			if(j>=w[i][0]+w[i][2])
			f[j]=max(f[j],f[j-w[i][0]-w[i][2]]+w[i][0]*v[i][0]+w[i][2]*v[i][2]);
		}
	}
	cout<<f[n];
}

混合背包问题

第一层for循环打开，加个判断，判断里每种背包，各写各的

int f[1005];
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		int v,w,s;
		cin>>v>>w>>s;
		if(s==0)//完全背包 
		{
			for(int j=v;j<=m;j++)
			f[j]=max(f[j],f[j-v]+w);
		}
		else//01或多重背包
		{
			if(s==-1)
			s=1;
			for(int j=1;j<=s;j*=2)
			{
				for(int k=m;k>=v*j;k--)
				{
					f[k]=max(f[k],f[k-j*v]+j*w);
				}
				s-=j;
			}
			if(s)
			{
				for(int k=m;k>=s*v;k--)
				f[k]=max(f[k],f[k-s*v]+s*w);
			}
		}
	}
	cout<<f[m];
}

有依赖的背包问题

背包问题求方案数

令f[j]是容量j恰好装满时的最大价值

g[j]是容量j达到最大价值的方案数

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

所以若f[i][j]==f[i-1][j] g[i][j]=g[i-1][j]

若f[i][j]==f[i-1][j-v]+w g[i][j]=g[i-1][j-v]

若f[i][j]==f[i-1][j]且f[i][j]==f[i-1][j-v]+w g[i][j]=g[i-1][j]+g[i-1][j-v]

对于最大价值res，所有的对应g的和即为总方案

const int mod=1e9+7;
int f[1005],g[1005];
int main()
{
	memset(f,-0x3f,sizeof(f));
	f[0]=0;g[0]=1;
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	{
		int v,w;
		cin>>v>>w;
		for(int j=m;j>=v;j--)
		{
			int maxx=max(f[j],f[j-v]+w),cnt=0;
			if(maxx==f[j])
			cnt+=g[j];
			if(maxx==f[j-v]+w)
			cnt+=g[j-v];
			g[j]=cnt%mod;
			f[j]=maxx;
		}
	}
	int res=0,mm=0;
	for(int i=1;i<=m;i++)
	{
		res=max(res,f[i]);
	}
	for(int i=1;i<=m;i++)//important
	{
		if(f[i]==res)
		mm=(mm+g[i])%mod;
	}
	cout<<mm;
}

能量石模型

为什么贪心？

与经典01背包不一样，只需要确定拿哪几个物品即可，而此模型下相同物品不同的拿取顺序可直接改变最终的结果。所以贪心的目的仅仅是在确定拿哪几个物品的前提下，以如何的顺序去拿取

而不能直接贪心顺序拿取解决

为什么f初始化为-0x3f ？

以前能算到至多是 j 是因为dp[0][j]都是0，即从i=0时从哪个体积开始都是合法的，相当于把空余的体积加在了最前面，但现在这样不是最优,如果背包没有装满，就有前置空间浪费，造成能量损失。

struct node
{
	int s,e,l;
}stone[105];
int cmp(node a,node b)
{
	return a.l*b.s>b.l*a.s;
}
int f[100005];
int main()
{
	int T,c=1;
	cin>>T;
	while(T--)
	{
		memset(f,-0x3f,sizeof(f));
		f[0]=0;
		int n,m=0;
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		{
			scanf("%d%d%d",&stone[i].s,&stone[i].e,&stone[i].l);
			m+=stone[i].s;
		}
		sort(stone+1,stone+1+n,cmp);
		for(int i=1;i<=n;i++)
		{
			int s=stone[i].s,e=stone[i].e,l=stone[i].l;
			for(int j=m;j>=s;j--)
			{
				f[j]=max(f[j],f[j-s]+e-(j-s)*l);
			}
		}
		int res=0;
		for(int i=0;i<=m;i++)
		res=max(res,f[i]);
		printf("Case #%d: %d\n",c++,res);
	}
}