ZOJ 3617 Riding Alone for Thousands of Miles(贪心+线段树)

转载请注明出处，谢谢http://blog.csdn.net/acm_cxlove/article/details/7854526       by---cxlove 

题目：给出一些关卡，按顺序攻破，每个关卡有一定的防御值，攻破需要一定的HP消耗，但是关卡被攻破之后，可以选择休息，每休息一天，能恢复一定的HP值，不过HP值有一个上限，而且攻破关卡不需要耗时

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4741 

贪心。

因为总的消耗是一定的，需要恢复的时间越少，也就是每次恢复的量越多越好。

考虑每一个关卡，之后比他恢复小的，尽量不休息，也就是当前的HP要尽可能坚持到比它恢复大的一个关卡

如果在当前关卡恢复若干次之后，恰能到达下一个恢复大的关卡，那么这样肯定是最优的。

如果当前即使加满也不能到达，即在中间可能还有停靠点。

这时候需要注意了，首先先尽量加，但是不 要溢出。则剩余有空间是maxhp-hp，在当前关卡加一次会溢出，则在中间考虑有没有比这恢复大的，有且能到达，则考虑。否则在当前加满。

#include<iostream>  
#include<cstdio>  
#include<map>  
#include<cstring>  
#include<cmath>  
#include<vector>  
#include<queue>  
#include<algorithm>  
#include<set> 
#include<string>
#define inf 1<<30
#define N 100005
#define maxn 100005
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define pb(a) push_back(a)
#define mem(a,b) memset(a,b,sizeof(a))
#define eps 1e-9
#define zero(a) fabs(a)<eps
#define LL long long  
#define ULL unsigned long long  
#define lson (step<<1),l,m 
#define rson (step<<1|1),m+1,r 
#define MOD 1000000007  
#define mp(a,b) make_pair(a,b)  
using namespace std;  
struct Node{
	int cost,val;
}a[N];
int mx[N*5];
void Push_Up(int step){
	int l=step<<1,r=step<<1|1;
	mx[step]=max(mx[l],mx[r]);
}
void Bulid(int step,int l,int r){
	if(l==r) {mx[step]=a[l].val;return;}
	int m=(l+r)/2;
	Bulid(lson);
	Bulid(rson);
	Push_Up(step);
}
int Query(int step,int l,int r,int L,int R,int k){
	if(mx[step]<k) return -1;
	int m=(l+r)/2,ret=-1;
	if(l==r) return l;
	if(L<=m) ret=Query(lson,L,R,k);
	if(R>m&&ret==-1) ret=Query(rson,L,R,k);
	return ret;
}
LL sum[N]={0};
int main(){
	int n,maxhp;
	while(scanf("%d%d",&n,&maxhp)!=EOF){
		LL ans=0,hp=maxhp;
		for(int i=1;i<=n;i++){
			scanf("%d%d",&a[i].cost,&a[i].val);
			sum[i]=sum[i-1]+a[i].cost;
		}
		Bulid(1,1,n);
		for(int i=1;i<=n;i++){
			hp-=a[i].cost;
			int id=Query(1,1,n,i+1,n,a[i].val);
			if(id==-1) id=n;   //如果之后没有更优的，那就直接考虑到通关
			if(sum[id]-sum[i]>=hp){
				//不考虑上限，需要多少次能到达下一次最优点
				LL t=(sum[id]-sum[i]-hp)/a[i].val+1;
				//加上补充，可以不超过上限
				if(hp+t*a[i].val<=maxhp){
					hp+=t*a[i].val;
					ans+=t;
					if(id!=n){				
						hp-=sum[id-1]-sum[i];
						i=id-1;
					}
				}
				else{
					t=(maxhp-hp)/a[i].val;//表示当前不浪费，最多补充几次
					ans+=t;
					hp+=t*a[i].val;
					id=Query(1,1,n,i+1,n,maxhp-hp);
					if(id==-1) id=n;
					if(sum[id]-sum[i]>=hp){
						hp=maxhp;
						ans++;
					}
				}
			}
		}
		printf("%lld\n",ans);
	}
	return 0;
}