BZOJ 1571 [Usaco2009 Open]滑雪课Ski 动态规划

最新推荐文章于 2018-10-15 09:36:22 发布

MyZhY

最新推荐文章于 2018-10-15 09:36:22 发布

阅读量588

点赞数 1

CC 4.0 BY-SA版权

分类专栏： DP/记忆化搜索

本文链接：https://blog.youkuaiyun.com/ThinFatty/article/details/78076655

DP/记忆化搜索专栏收录该内容

63 篇文章

订阅专栏

Bessie要在有限时间内参加滑雪课程并尽可能多地滑雪。通过动态规划算法，考虑课程开始时间、持续时间和提升的滑雪技能，以及不同斜坡所需的滑雪能力和滑行时间，来最大化滑雪次数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Description

Farmer John 想要带着 Bessie 一起在科罗拉多州一起滑雪。很不幸，Bessie滑雪技术并不精湛。 Bessie了解到，在滑雪场里，每天会提供S(0<=S<=100)门滑雪课。第i节课始于M_i(1<=M_i<=10000),上的时间为L_i(1<=L_i<=10000)。上完第i节课后，Bessie的滑雪能力会变成A_i(1<=A_i<=100). 注意：这个能力是绝对的，不是能力的增长值。 Bessie买了一张地图，地图上显示了N(1 <= N <= 10,000)个可供滑雪的斜坡，从第i个斜坡的顶端滑至底部所需的时长D_i(1<=D_i<=10000)，以及每个斜坡所需要的滑雪能力C_i(1<=C_i<=100)，以保证滑雪的安全性。Bessie的能力必须大于等于这个等级，以使得她能够安全滑下。 Bessie可以用她的时间来滑雪，上课，或者美美地喝上一杯可可汁，但是她必须在T(1<=T<=10000)时刻离开滑雪场。这意味着她必须在T时刻之前完成最后一次滑雪。求Bessie在实现内最多可以完成多少次滑雪。这一天开始的时候，她的滑雪能力为1.

Input

第1行：3个用空格隔开的整数：T, S, N。

第2~S+1行:第i+1行用3个空格隔开的整数来描述编号为i的滑雪课：M_i,L_i,A_i。

第S+2~S+N+1行：

第S+i+1行用2个空格隔开的整数来描述第i个滑雪坡：C_i,D_i。

Output

一个整数，表示Bessie在时间限制内最多可以完成多少次滑雪。

Sample Input

10 1 2
3 2 5
4 1
1 3

Sample Output

HINT

滑第二个滑雪坡1次，然后上课，接着滑5次第一个滑雪坡。

传送门

比较容易想到dp，

dp[time][abl]表示在time时刻能力值为abl的最多滑雪次数。

如果说当前选择上第x堂滑雪课，

（前提是M[x]<=time）我们可以得到：

dp[time+L[x]][max(abl,A[x]]=max{dp[time][abl]}

然后假如说这个点啥都不干，就是

dp[time+1][abl]=max{dp[time][abl]}

划第y个坡道，

(前提是abl>=C[y])，得到：

dp[time+D[y]][abl]=max{dp[time][abl]+1}

分析一下，空间复杂度O(TA)，是可以接受的，

但是时间复杂度，由于要枚举所有的滑雪课、坡道，

时间复杂度是O(TA(S+N))，虽然O(TAS)是可能可以过的，但是N有10000……所以会炸

我一开始竟然看错数据范围了= =

那么如何优化呢？很简单有个贪心的想法，

滑雪坡道的选择，所有合法的里面，肯定选择D[y]最小的那个。

对于abl>=C[y]的前提，因为abl是从1~100枚举的，所以我们按照C排序，

然后就可以用一个不退的指针维护min；

时间复杂度O(TAS+TN)，按理说可以卡过了。

然而洛谷无情……

同理选择滑雪课也可以用这种方法。

按照M排序，那么我们对于滑雪课的选择也可以用同样的方法了。

时间复杂度O(TA+TS+TN)。

#include<bits/stdc++.h>
using namespace std;
int read(){
	int x=0,f=1;char ch=getchar();
	while (ch<'0'||ch>'9'){if (ch=='-') f=-1;ch=getchar();}
	while (ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
const int 
	CRS=105,ABL=105,
	N=10005,
	TIME=10005;
int T,S,n;
int dp[TIME][ABL];
struct Course{int M,L,A;}crs[CRS];
struct Hillside{int C,D;}hs[N];
bool cmp1(Course x,Course y){
	return x.M<y.M;
}
bool cmp2(Hillside x,Hillside y){
	return x.C<y.C;
}
int DP(){
	memset(dp,128,sizeof(dp));
	dp[0][1]=0;
	for (int i=0;i<T;i++){
		int MIN=0,k=1,p=1;
		for (int j=1;j<=100;j++){
			dp[i+1][j]=max(dp[i+1][j],dp[i][j]);
			while (k<=S && crs[k].M<=i+1){
				if (crs[k].A>j && i+crs[k].L<=T)
					dp[i+crs[k].L][crs[k].A]=max(dp[i+crs[k].L][crs[k].A],dp[i][j]);
				k++;
			}

			while (p<=n && j>=hs[p].C){
				if (hs[p].D<hs[MIN].D) MIN=p;
				p++;
			}
			if (i+hs[MIN].D<=T)
				dp[i+hs[MIN].D][j]=max(dp[i+hs[MIN].D][j],dp[i][j]+1);
		}
	}

	int ans=0;
	for (int i=1;i<=100;i++) ans=max(ans,dp[T][i]);
	return ans;
}
int main(){
	T=read() ,S=read(),n=read();
	for (int i=1;i<=S;i++)
		crs[i].M=read(),crs[i].L=read(),crs[i].A=read();
	hs[0].D=10001;
	for (int i=1;i<=n;i++) hs[i].C=read(),hs[i].D=read();

	sort(crs+1,crs+1+S,cmp1);
	sort(hs+1,hs+1+n,cmp2);

	printf("%d\n",DP());
	return 0;
}