动态规划的模版题
樱花
题目背景
《爱与愁的故事第四弹·plant》第一章。
题目描述
爱与愁大神后院里种了 n n n 棵樱花树,每棵都有美学值 C i ( 0 ≤ C i ≤ 200 ) C_i(0 \le C_i \le 200) Ci(0≤Ci≤200)。爱与愁大神在每天上学前都会来赏花。爱与愁大神可是生物学霸,他懂得如何欣赏樱花:一种樱花树看一遍过,一种樱花树最多看 A i ( 0 ≤ A i ≤ 100 ) A_i(0 \le A_i \le 100) Ai(0≤Ai≤100) 遍,一种樱花树可以看无数遍。但是看每棵樱花树都有一定的时间 T i ( 0 ≤ T i ≤ 100 ) T_i(0 \le T_i \le 100) Ti(0≤Ti≤100)。爱与愁大神离去上学的时间只剩下一小会儿了。求解看哪几棵樱花树能使美学值最高且爱与愁大神能准时(或提早)去上学。
输入格式
共 n + 1 n+1 n+1行:
第
1
1
1 行:现在时间
T
s
T_s
Ts(几时:几分),去上学的时间
T
e
T_e
Te(几时:几分),爱与愁大神院子里有几棵樱花树
n
n
n。这里的
T
s
T_s
Ts,
T
e
T_e
Te 格式为:hh:mm
,其中
0
≤
h
h
≤
23
0 \leq hh \leq 23
0≤hh≤23,
0
≤
m
m
≤
59
0 \leq mm \leq 59
0≤mm≤59,且
h
h
,
m
m
,
n
hh,mm,n
hh,mm,n 均为正整数。
第 2 2 2 行到第 n + 1 n+1 n+1 行,每行三个正整数:看完第 i i i 棵树的耗费时间 T i T_i Ti,第 i i i 棵树的美学值 C i C_i Ci,看第 i i i 棵树的次数 P i P_i Pi( P i = 0 P_i=0 Pi=0 表示无数次, P i P_i Pi 是其他数字表示最多可看的次数 P i P_i Pi)。
输出格式
只有一个整数,表示最大美学值。
样例 #1
样例输入 #1
6:50 7:00 3
2 1 0
3 3 1
4 5 4
样例输出 #1
11
提示
100 % 100\% 100% 数据: T e − T s ≤ 1000 T_e-T_s \leq 1000 Te−Ts≤1000(即开始时间距离结束时间不超过 1000 1000 1000 分钟), n ≤ 10000 n \leq 10000 n≤10000。保证 T e , T s T_e,T_s Te,Ts 为同一天内的时间。
样例解释:赏第一棵樱花树一次,赏第三棵樱花树 2 2 2 次。
思路
这道题目考查的算法知识是多重背包.
在开始的时候,我以为只需要三重循环就可以过了,但是直接TLE了一发(╥﹏╥),属实是我偷懒没看时间复杂度,这个算法复杂度是O(TnA),大概在10的9次幂,完美超时.
核心代码如下(三个循环的顺序只能是这样,外层毫无疑问.体积必须要在外侧,因为当前种类的物品只能由上一种类的物品转移过来)
for(int i=1;i<=n;i++)
{
for(int j=T;j>=times[i];j--)
{
for(int z=0;z<=k[i];z++)
{
if(z*times[i]<=j)
{
dp[j]=max(dp[j],dp[j-z*times[i]]+val[i]*z);
}
}
}
}
为了优化这个代码的时间复杂度,优化一下A,于是就有了接下来的二进制优化
大致的实现就是从原来的一个一个放,变成一组一组放,这样就控制了放置次数在10次以内.就能满足最坏情况.
再优化一下n,当Ai大与最大能放的值的时候,就可以当作是完全背包来存放,也就是从多重背包变为完全背包,可以优化一点常数,
代码实现
#include <bits/stdc++.h>
using namespace std;
int main()
{
int begin_h,begin_m;
int end_h,end_m;
char c;
cin>>begin_h>>c>>begin_m>>end_h>>c>>end_m;
int T=0;
T=end_h*60+end_m-begin_h*60-begin_m;
int n;
cin>>n;
int val[10001]={},times[10001]={},k[10001]={};
for(int i=1;i<=n;i++)
{
cin>>times[i]>>val[i]>>k[i];
}
int dp[1001]={};
for(int i=1;i<=n;i++)
{
if(k[i]*times[i]>=T || k[i]==0) //转换为完全背包
{
for(int j=times[i];j<=T;j++)
{
dp[j]=max(dp[j],dp[j-times[i]]+val[i]);
}
}
else
{
int num=1;
while(k[i]>num)
{
for(int j=T;j>=times[i]*num;j--)
{
dp[j]=max(dp[j],dp[j-times[i]*num]+val[i]*num);
}
k[i]-=num;
num*=2;
}
for(int j=T;j>=k[i]*times[i];j--)
{
dp[j]=max(dp[j],dp[j-k[i]*times[i]]+val[i]*k[i]);
}
}
}
cout<<dp[T]<<endl;
return 0;
}
[NOIP2012 普及组] 摆花
题目描述
小明的花店新开张,为了吸引顾客,他想在花店的门口摆上一排花,共 m m m 盆。通过调查顾客的喜好,小明列出了顾客最喜欢的 n n n 种花,从 1 1 1 到 n n n 标号。为了在门口展出更多种花,规定第 i i i 种花不能超过 a i a_i ai 盆,摆花时同一种花放在一起,且不同种类的花需按标号的从小到大的顺序依次摆列。
试编程计算,一共有多少种不同的摆花方案。
输入格式
第一行包含两个正整数 n n n 和 m m m,中间用一个空格隔开。
第二行有 n n n 个整数,每两个整数之间用一个空格隔开,依次表示 a 1 , a 2 , ⋯ , a n a_1,a_2, \cdots ,a_n a1,a2,⋯,an。
输出格式
一个整数,表示有多少种方案。注意:因为方案数可能很多,请输出方案数对 1 0 6 + 7 10^6+7 106+7 取模的结果。
样例 #1
样例输入 #1
2 4
3 2
样例输出 #1
2
提示
【数据范围】
对于 20 % 20\% 20% 数据,有 0 < n ≤ 8 , 0 < m ≤ 8 , 0 ≤ a i ≤ 8 0<n \le 8,0<m \le 8,0 \le a_i \le 8 0<n≤8,0<m≤8,0≤ai≤8。
对于 50 % 50\% 50% 数据,有 0 < n ≤ 20 , 0 < m ≤ 20 , 0 ≤ a i ≤ 20 0<n \le 20,0<m \le 20,0 \le a_i \le 20 0<n≤20,0<m≤20,0≤ai≤20。
对于 100 % 100\% 100% 数据,有 0 < n ≤ 100 , 0 < m ≤ 100 , 0 ≤ a i ≤ 100 0<n \le 100,0<m \le 100,0 \le a_i \le 100 0<n≤100,0<m≤100,0≤ai≤100。
NOIP 2012 普及组 第三题
思路
这道题主要难在状态转移方程和代码实现
我们设 $ dp[i][j] $ 表示i种花盆, j j j 个位置能实现的方案数
于是就能写出:
d p [ i ] [ j ] = d p [ i − 1 ] [ j ] + d p [ i − 1 ] [ j − 1 ] + ⋯ + d p [ i − 1 ] [ j − m i n ( j , a [ i ] ) ] dp[i][j] = dp[i-1][j] + dp[i-1][j-1] + \cdots + dp[i-1][j-min(j,a[i])] dp[i][j]=dp[i−1][j]+dp[i−1][j−1]+⋯+dp[i−1][j−min(j,a[i])]
我们会发现每个第一个维度可以直接去掉,并且对于位置长度为 j j j 的 d p [ j ] dp[j] dp[j] ,是由长度不大于 j j j 的状态转移过来,所以 j j j 要从大到小循环
「当时我在写的时候推出状态转移方程了,但是没写出来,说明代码实现能力还是比较弱,还是要多写题目」
代码实现
#include<bits/stdc++.h>
using namespace std;
const int maxn=101;
const int mod=1e6+7;
int a[maxn]={};
int dp[maxn]={};
int main()
{
int n,m;
cin>>n>>m;
dp[0]=1;
for(int i=1;i<=n;i++) cin>>a[i];
for(int i=1;i<=n;i++)
{
for(int j=m;j>=1;j--)
{
for(int z=j-1;z>=j-a[i]&& z>=0;z--)
{
dp[j]=(dp[j]+dp[z]) %mod;
}
}
}
cout<<dp[m]<<endl;
return 0;
}
[NOIP2006 提高组] 金明的预算方案
题目描述
金明今天很开心,家里购置的新房就要领钥匙了,新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是,妈妈昨天对他说:“你的房间需要购买哪些物品,怎么布置,你说了算,只要不超过 n n n 元钱就行”。今天一早,金明就开始做预算了,他把想买的物品分为两类:主件与附件,附件是从属于某个主件的,下表就是一些主件与附件的例子:
主件 | 附件 |
---|---|
电脑 | 打印机,扫描仪 |
书柜 | 图书 |
书桌 | 台灯,文具 |
工作椅 | 无 |
如果要买归类为附件的物品,必须先买该附件所属的主件。每个主件可以有 0 0 0 个、 1 1 1 个或 2 2 2 个附件。每个附件对应一个主件,附件不再有从属于自己的附件。金明想买的东西很多,肯定会超过妈妈限定的 n n n 元。于是,他把每件物品规定了一个重要度,分为 5 5 5 等:用整数 1 ∼ 5 1 \sim 5 1∼5 表示,第 5 5 5 等最重要。他还从因特网上查到了每件物品的价格(都是 10 10 10 元的整数倍)。他希望在不超过 n n n 元的前提下,使每件物品的价格与重要度的乘积的总和最大。
设第 j j j 件物品的价格为 v j v_j vj,重要度为 w j w_j wj,共选中了 k k k 件物品,编号依次为 j 1 , j 2 , … , j k j_1,j_2,\dots,j_k j1,j2,…,jk,则所求的总和为:
v j 1 × w j 1 + v j 2 × w j 2 + ⋯ + v j k × w j k v_{j_1} \times w_{j_1}+v_{j_2} \times w_{j_2}+ \dots +v_{j_k} \times w_{j_k} vj1×wj1+vj2×wj2+⋯+vjk×wjk。
请你帮助金明设计一个满足要求的购物单。
输入格式
第一行有两个整数,分别表示总钱数 n n n 和希望购买的物品个数 m m m。
第 2 2 2 到第 ( m + 1 ) (m + 1) (m+1) 行,每行三个整数,第 ( i + 1 ) (i + 1) (i+1) 行的整数 v i v_i vi, p i p_i pi, q i q_i qi 分别表示第 i i i 件物品的价格、重要度以及它对应的的主件。如果 q i = 0 q_i=0 qi=0,表示该物品本身是主件。
输出格式
输出一行一个整数表示答案。
样例 #1
样例输入 #1
1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0
样例输出 #1
2200
提示
数据规模与约定
对于全部的测试点,保证 1 ≤ n ≤ 3.2 × 1 0 4 1 \leq n \leq 3.2 \times 10^4 1≤n≤3.2×104, 1 ≤ m ≤ 60 1 \leq m \leq 60 1≤m≤60, 0 ≤ v i ≤ 1 0 4 0 \leq v_i \leq 10^4 0≤vi≤104, 1 ≤ p i ≤ 5 1 \leq p_i \leq 5 1≤pi≤5, 0 ≤ q i ≤ m 0 \leq q_i \leq m 0≤qi≤m,答案不超过 2 × 1 0 5 2 \times 10^5 2×105。
思路
这道题可以用分组背包来写.我们虚拟一个最大的背包,包裹着所有的分组背包.
每个主件都当作一个背包,它对应的附件都属于对应的主件的背包中.
对每个背包,刚开始都先从最大的背包那里得到初始状态.但是要做一点小改变,因为这个背包必须要加上主件,所以在刚开始的dp值要加上主件的值.然后单独用01背包处理.接着要注意,在体积的那个循环那里,下限要算上之前已经放的主件的体积.最后,要把当前的背包得到的状态更新到最大的背包那里.
输出最大的背包的 d p [ m ] dp[m] dp[m] 值即可
时间复杂度小优化:
刚开始就直接把每个背包分开来,用vector存储,这样在弄01背包的时候就可以直接进行,不用从头到尾去找当前主件对应的附件,这样就节省了枚举次数.
「这道题还可以用四种动态规划方程去写,思路也很清晰,但是当附件数变多的时候,这种方法就不可取了,所以这里还是用了分组背包的方法」
代码实现
#include<bits/stdc++.h>
using namespace std;
const int maxn=61;
struct good
{
int v,p,q;
}G;
vector<good> V[maxn];
int inde[maxn]={};
int main()
{
int n,m;
int v,p,q;
cin>>n>>m;
int temp=1;
for(int i=1;i<=m;i++)
{
cin>>v>>p>>q;
G.v=v,G.p=p*v,G.q=q;
if(q==0)
{
V[temp].push_back(G);
inde[i]=temp;
temp++;
}
else
{
V[inde[q]].push_back(G);
}
}
--temp;
int f[200005]={};
int h[200005]={};
for(int i=1;i<=temp;i++)
{
for(int j=V[i][0].v;j<=n;j++)
{
h[j]=f[j-V[i][0].v]+V[i][0].p;
}
for(int j=1;j<=V[i].size()-1;j++)
{
for(int z=n;z>=V[i][0].v+V[i][j].v;z--)
{
h[z]=max(h[z],h[z-V[i][j].v]+V[i][j].p);
}
}
for(int j=V[i][0].v;j<=n;j++)
{
f[j]=max(f[j],h[j]);
}
}
cout<<f[n]<<endl;
return 0;
}
总结
这次的动态规划有点难度了,但其实还主要是模版的运用,主要考察了多重背包和分组背包
多重背包可以用完全背包和二进制优化
分组背包要注意大背包数据的引入和更新
感觉多看看就有点懂了,但是说不出所以然(呜呜呜)