自己写的笔记，不建议其他人参考学习
不自量力警告
1.1数字三角形模型
说白了，就是数塔，简单粗暴
在此基础上，我们很容易就可以 想出来它的进阶版本
同样简单无脑
双重for循环再配上，简单的动态转移方程
f[i][j]=max(f[i-1][j]+f[i][j-1])+w[i][j]
现在我们升级问题
题意大概就是方形数塔，连续跑两次求和的最大值，两次取的数字不能重复计入
错误思路：
第一反应是 跑两遍
随即就意识到了实现的复杂性
由于动态规划跑了一次并没有追溯路径，所以第二次并不知道哪些数字还存在
随即可以想到使用四维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);
}
}
3033
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
