约会安排 HDU - 4553 （线段树区间合并）

　寒假来了，又到了小明和女神们约会的季节。 
　　小明虽为屌丝级码农，但非常活跃，女神们常常在小明网上的大段发言后热情回复“呵呵”，所以，小明的最爱就是和女神们约会。与此同时，也有很多基友找他开黑，由于数量实在过于巨大，怎么安排时间便成了小明的一大心事。 
　　我们已知小明一共有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 2

Sample 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

解:  将一个时间段分为两个区间，区间A表示和女神约的时间分布，区间B表示有人约的时间分布，若有基友约，直接判断B区间是否还有位置，有就更新B区间，若有女神约，则先判断B区间是否有位置，有就同时更新区间A和B，否则再判断A区间是否有位置，若有还是同时更新区间A和B

这里的lazy标记我是直接用 最长连续区间的值表示  因为答应基友或者女神 那么有一段的最长连续区间肯定为0

如果要学习 那么这一段的最长连续区间恢复成这一段的长度

#include<stdio.h>
#include<string.h>
#include<map>
#include<vector>
#include<iostream>
#include<algorithm>
#include<queue>
#include<deque>
#include<math.h>
#define ll long long
#define ls rt<<1
#define rs rt<<1|1
#define maxn 100000+10
struct node
{
    int l,r,m;//l 包含左端点的最长连续区间  ，r包含右端点的最长连续区间  m 最长连续区间
}a[maxn<<2],b[maxn<<2];//a代表有人约的时间  ，b代表女神
using namespace std;
void build(int l,int r,int rt)
{
   a[rt].l=a[rt].r=a[rt].m=r-l+1;
   b[rt].l=b[rt].r=b[rt].m=r-l+1;
   if(l!=r)
   {
       int m=(l+r)>>1;
       build(l,m,ls);
       build(m+1,r,rs);
   }
}
void pushup(int l,int r,int rt)
{
    int m=(l+r)>>1;
    a[rt].l=a[ls].l;//左子树的左连续区间肯定是父亲节点左连续区间的一部分
    a[rt].r=a[rs].r;//同理
    a[rt].m=max(max(a[ls].m,a[rs].m),a[ls].r+a[rs].l);//父亲节点的最长连续区间要么是 左子树的最长连续区间 要么  右子树的最长连续区间  要么 左子树右连续+右子树左连续
    if(a[ls].l==m-l+1) a[rt].l+=a[rs].l;//如果左子树的左连续长度为整个左子树的长度，那么父亲节点的左连续区间得加上 右子树的左连续区间
    if(a[rs].r==r-m)   a[rt].r+=a[ls].r;//同理

    b[rt].l=b[ls].l;
    b[rt].r=b[rs].r;
    b[rt].m=max(max(b[ls].m,b[rs].m),b[ls].r+b[rs].l);
    if(b[ls].l==m-l+1) b[rt].l+=b[rs].l;
    if(b[rs].r==r-m)   b[rt].r+=b[ls].r;
}
void pushdown(int l,int r,int rt)//下推标记
{
    int m=(l+r)>>1;
    if(a[rt].m==r-l+1)//可能是学习操作造成的要下推
    {
        a[ls].l=a[ls].r=a[ls].m=m-l+1;
        a[rs].l=a[rs].r=a[rs].m=r-m;
    }
    else if(a[rt].m==0)//由约人操作造成
    {
         a[ls].l=a[ls].r=a[ls].m=0;
        a[rs].l=a[rs].r=a[rs].m=0;
    }
    if(b[rt].m==r-l+1)
    {
        b[ls].l=b[ls].r=b[ls].m=m-l+1;
        b[rs].l=b[rs].r=b[rs].m=r-m;
    }
    else if(b[rt].m==0)
    {
         b[ls].l=b[ls].r=b[ls].m=0;
        b[rs].l=b[rs].r=b[rs].m=0;
    }
}
void update(int L,int R,int l,int r,int rt,int x)
{
    if(L<=l&&r<=R)
    {
        if(x==1)//基友
            a[rt].l=a[rt].m=a[rt].r=0;
        else if(x==0)//女神
            b[rt].l=b[rt].m=b[rt].r=a[rt].l=a[rt].m=a[rt].r=0;//要同时修改两个区间
        else//学习
            b[rt].l=b[rt].m=b[rt].r=a[rt].l=a[rt].m=a[rt].r=r-l+1;//同时修改两个
        return;
    }
    pushdown(l,r,rt);
    int m=(l+r)>>1;
    if(L<=m) update(L,R,l,m,ls,x);
    if(R>m) update(L,R,m+1,r,rs,x);
    pushup(l,r,rt);
}
int query(int l,int r,int rt,int x,int p)
{
    if(l==r) return l;
    pushdown(l,r,rt);
    int m=(l+r)>>1;
    if(p)//基友
    {
    if(a[ls].m>=x)//左子树最长连续长度满足 x，最左端的点肯定在左子树
        return query(l,m,ls,x,p);
    else if(a[ls].r+a[rs].l>=x)//左子树的右区间+右子树的左区间 长度满足x ，左端点肯定是 左子树右区间的起始点
        return m-a[ls].r+1;
    else//否则在右子树
        return query(m+1,r,rs,x,p);
    }
    else//女神
    {
    if(b[ls].m>=x)
        return query(l,m,ls,x,p);
    else if(b[ls].r+b[rs].l>=x)
        return m-b[ls].r+1;
    else
        return query(m+1,r,rs,x,p);
    }
}
int main()
{
    char ch[10];
    int t,n,m,l,r,k;
    scanf("%d",&t);
    for(int ppp=1;ppp<=t;ppp++)
    {
        printf("Case %d:\n",ppp);
        scanf("%d%d",&n,&m);
        build(1,n,1);
        while(m--)
        {
           scanf("%s",ch);
           if(ch[0]=='D')
           {
               scanf("%d",&l);
               if(a[1].m>=l)//看整个区间内的最长连续区间是否满足x
               {
                k=query(1,n,1,l,1);
                printf("%d,let's fly\n",k);
                update(k,k+l-1,1,n,1,1);
               }
               else
                printf("fly with yourself\n");
           }
           else if(ch[0]=='N')
           {
               scanf("%d",&l);
               if(a[1].m>=l)
               {
                   k=query(1,n,1,l,1);
                   printf("%d,don't put my gezi\n",k);
                   update(k,k+l-1,1,n,1,0);
               }
               else if(b[1].m>=l)
               {
                   k=query(1,n,1,l,0);
                   printf("%d,don't put my gezi\n",k);
                   update(k,k+l-1,1,n,1,0);
               }
               else
                printf("wait for me\n");
           }
           else
           {
               scanf("%d%d",&l,&r);
               update(l,r,1,n,1,2);
               printf("I am the hope of chinese chengxuyuan!!\n");
           }
        }
    }
}