约会安排
HDU 4553 https://vjudge.net/contest/293027#problem/L
注意区间索引方法和Lazy标记的优先级
寒假来了，又到了小明和女神们约会的季节。
小明虽为屌丝级码农，但非常活跃，女神们常常在小明网上的大段发言后热情回复“呵呵”，所以，小明的最爱就是和女神们约会。与此同时，也有很多基友找他开黑，由于数量实在过于巨大，怎么安排时间便成了小明的一大心事。
我们已知小明一共有T的空闲时间，期间会有很多女神或者基友来找小明。
作为一个操作系统曾经怒考71分的大神，小明想到了一个算法，即“首次适应算法”，根据操作系统课本的描述，就是找一段最靠前的符合要求的连续空间分配给每个请求，由此小明做出了一个决定：
当一个基友来找小明时，小明就根据“首次适应算法”来找一段空闲的时间来和基友约好，如果找到，就说“X,let’s fly”（此处，X为开始时间），否则就说“fly with yourself”；
当女神来找小明时，先使用一次“首次适应算法”，如果没有找到，小明就冒着木叽叽的风险无视所有屌丝基友的约定，再次使用“无视基友首次适应算法”，两次只要有一次找到，就说“X,don’t put my gezi”（此处，X为开始时间），否则就说“wait for me”
当然，我们知道小明不是一个节操负无穷的人，如果和女神约会完，还有剩余时间，他还是会和原来约好的基友去dota的。（举个例子：小西（屌丝）和小明约好在1~5这个时间单位段内打dota，这时候，女神来和小明预约长度为3的时间段，那么最终就是1~3小明去和女神约会，搞定后在4~5和小西打dota）
小明偶尔也会想要学习新知识，此时小明就会把某一个时间区间的所有已经预定的时间全部清空用来学习并且怒吼“I am the hope of chinese chengxuyuan!!”，不过小明一般都是三分钟热度，再有人来预定的话，小明就会按耐不住寂寞把学习新知识的时间分配出去。
Input
输入第一行为CASE，表示有CASE组测试数据；
每组数据以两个整数T，N开始，T代表总共的时间，N表示预约请求的个数；
接着的N行，每行表示一个女神或者基友的预约，“NS QT”代表一个女神来找小明约一段长为QT的时间，“DS QT”则代表一个屌丝的长为QT的请求，当然也有可能是小明想学知识了，“STUDY!! L R”代表清空L~R区间内的所有请求。
[Technical Specification]
1. 1 <= CASE <= 30
2. 1 <= T, N <= 100000
3. 1 <= QT <= 110000
4. 1 <= L <= R <=T
Output
对于每一个case，第一行先输出“Case C:”代表是第几个case，然后N行，每行对应一个请求的结果(参照描述)。
输出样本(可复制此处)：
“X,let's fly”,”fly with yourself”,”X,don't put my gezi”,”wait for me”,”I am the hope of chinese chengxuyuan!!”
Sample Input
1
5 6
DS 3
NS 2
NS 4
STUDY!! 1 5
DS 4
NS 2Sample Output
Case 1:
1,let's fly
4,don't put my gezi
wait for me
I am the hope of chinese chengxuyuan!!
1,let's fly
1,don't put my gezi#include <iostream>
#include <cstdio>0
#include <string>
#include <cstring>
#include <algorithm>
#include <stack>
#include <cmath>
#include <vector>
using namespace std;
const int NUM=100005;
struct point
{
int l,r;
int dls,drs,dms,df;
int nls,nrs,nms,nf;
} tree[NUM*4];
int LL,RR,val,ans,n,m;
void build(int k,int LL,int RR)
{
tree[k].l=LL,tree[k].r=RR;
tree[k].dls=tree[k].drs=tree[k].dms=tree[k].nls=tree[k].nrs=tree[k].nms=tree[k].r-tree[k].l+1;
tree[k].df=tree[k].nf=-1;
if(tree[k].l==tree[k].r)
return;
int bet=(tree[k].l+tree[k].r)/2;
build(k*2,LL,bet);
build(k*2+1,bet+1,RR);
}
void down_n(int k)
{
tree[k*2].nf=tree[k*2+1].nf=tree[k].nf;
tree[k*2].dls=tree[k*2].drs=tree[k*2].dms=tree[k*2].nls=tree[k*2].nrs=tree[k*2].nms=(tree[k*2].r-tree[k*2].l+1)*tree[k].nf;
tree[k*2+1].dls=tree[k*2+1].drs=tree[k*2+1].dms=tree[k*2+1].nls=tree[k*2+1].nrs=tree[k*2+1].nms=(tree[k*2+1].r-tree[k*2+1].l+1)*tree[k].nf;
tree[k].nf=tree[k].df=-1;
}
void down_d(int k)
{
if(tree[k].l==tree[k].r)
return;
if(tree[k*2].nf==1)
down_n(k*2);
if(tree[k*2+1].nf==1)
down_n(k*2+1);
tree[k*2].df=tree[k*2+1].df=tree[k].df;
tree[k*2].dls=tree[k*2].drs=tree[k*2].dms=0;
tree[k*2+1].dls=tree[k*2+1].drs=tree[k*2+1].dms=0;
tree[k].df=-1;
}
bool intervalflag;
void find_interval_d(int k,int t)
{
if(tree[k].l==tree[k].r)
{
if(tree[k].dms>=t)
{
LL=tree[k].l;
RR=tree[k].r;
intervalflag=true;
}
return;
}
if(tree[k].nf!=-1)
down_n(k);
if(tree[k].df!=-1)
down_d(k);
if(tree[k*2].dms>=t)
find_interval_d(k*2,t);
else if(tree[k*2].drs+tree[k*2+1].dls>=t)
{
LL=tree[k*2].r-tree[k*2].drs+1;
RR=LL+t-1;
intervalflag=true;
}
else if(tree[k*2+1].dms>=t)
find_interval_d(k*2+1,t);
}
void find_interval_n(int k,int t)
{
if(tree[k].l==tree[k].r)
{
if(tree[k].nms>=t)
{
LL=tree[k*2].r-tree[k*2].nrs+1;
RR=LL+t-1;
intervalflag=true;
}
return;
}
if(tree[k].nf!=-1)
down_n(k);
if(tree[k].df!=-1)
down_d(k);
if(tree[k*2].nms>=t)
find_interval_n(k*2,t);
else if(tree[k*2].nrs+tree[k*2+1].nls>=t)
{
LL=tree[k*2].r-tree[k*2].nrs+1;
RR=LL+t-1;
intervalflag=true;
}
else if(tree[k*2+1].nms>=t)
find_interval_n(k*2+1,t);
}
void ask_d(int k)
{
if(tree[k].l==tree[k].r)
{
printf("%d ",tree[k].dms);
return ;
}
if(tree[k].nf!=-1)
down_n(k);
if(tree[k].df!=-1)
down_d(k);
ask_d(k*2),ask_d(k*2+1);
}
void ask_n(int k)
{
if(tree[k].l==tree[k].r)
{
return ;
}
if(tree[k].nf!=-1)
down_n(k);
if(tree[k].df!=-1)
down_d(k);
ask_n(k*2),ask_n(k*2+1);
}
void find_interval(int k,int t,int ch)
{
if(ch==1)
{
find_interval_d(k,t);
}
else
{
find_interval_d(k,t);
if(intervalflag==false)
{
find_interval_n(k,t);
}
}
}
void change(int k,int num,int ch)
{
if(LL<=tree[k].l&&RR>=tree[k].r)
{
if(ch==1)
{
if(tree[k].nf==1)
down_n(k);
tree[k].df=num;
tree[k].dls=tree[k].drs=tree[k].dms=0;
}
else
{
tree[k].nf=num;
tree[k].df=-1;
tree[k].dls=tree[k].drs=tree[k].dms=tree[k].nls=tree[k].nrs=tree[k].nms=(tree[k].r-tree[k].l+1)*tree[k].nf;
}
return;
}
if(tree[k].nf!=-1)
down_n(k);
if(tree[k].df!=-1)
down_d(k);
int bet=(tree[k].r+tree[k].l)/2;
if(LL<=bet)
change(k*2,num,ch);
if(RR>bet)
change(k*2+1,num,ch);
tree[k].dls=tree[k*2].dls;
tree[k].drs=tree[k*2+1].drs;
tree[k].dms=max(tree[k*2].drs+tree[k*2+1].dls,max(tree[k*2].dms,tree[k*2+1].dms));
if(tree[k*2].dls==tree[k*2].r-tree[k*2].l+1)
tree[k].dls+=tree[k*2+1].dls;
if(tree[k*2+1].drs==tree[k*2+1].r-tree[k*2+1].l+1)
tree[k].drs+=tree[k*2].drs;
tree[k].nls=tree[k*2].nls;
tree[k].nrs=tree[k*2+1].nrs;
tree[k].nms=max(tree[k*2].nrs+tree[k*2+1].nls,max(tree[k*2].nms,tree[k*2+1].nms));
if(tree[k*2].nls==tree[k*2].r-tree[k*2].l+1)
tree[k].nls+=tree[k*2+1].nls;
if(tree[k*2+1].nrs==tree[k*2+1].r-tree[k*2+1].l+1)
tree[k].nrs+=tree[k*2].nrs;
}
int main()
{
int t,cnt=1;
scanf("%d",&t);
for(int i=0; i<t; i++)
{
int n,m;
scanf("%d %d",&n,&m);
build(1,1,n);
string ss;
printf("Case %d:\n",cnt++);
for(int i=0; i<m; i++)
{
cin>>ss;
if(ss=="DS")
{
int time;
scanf("%d",&time);
if(time>n)
{
printf("fly with yourself\n");
continue;
}
intervalflag=false;
find_interval(1,time,1);
if(intervalflag==false)
printf("fly with yourself\n");
else
{
printf("%d,let's fly\n",LL);
change(1,0,1);
}
}
if(ss=="NS")
{
int time;
scanf("%d",&time);
if(time>n)
{
printf("wait for me\n");
continue;
}
intervalflag=false;
find_interval(1,time,2);
if(intervalflag==false)
printf("wait for me\n");
else
{
printf("%d,don't put my gezi\n",LL);
change(1,0,2);
}
}
if(ss=="STUDY!!")
{
scanf("%d %d",&LL,&RR);
printf("I am the hope of chinese chengxuyuan!!\n");
change(1,1,2);
}
}
}
return 0;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
