约会安排

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 147    Accepted Submission(s): 47

Problem Description 　　寒假来了，又到了小明和女神们约会的季节。

　　小明虽为屌丝级码农，但非常活跃，女神们常常在小明网上的大段发言后热情回复“呵呵”，所以，小明的最爱就是和女神们约会。与此同时，也有很多基友找他开黑，由于数量实在过于巨大，怎么安排时间便成了小明的一大心事。

　　我们已知小明一共有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  

Source
2013金山西山居创意游戏程序挑战赛——初赛（3）  

Recommend liuyiding         就是线段树。。。   进行两段区间合并操作    

//============================================================================
// Name        : C.cpp
// Author      : 
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <vector>
#include <string>
#include <math.h>
using namespace std;
const int MAXN=100010;
struct Node
{
    int l,r;
    int Max,Lmax,Rmax;
    int Max1,Lmax1,Rmax1;
}segTree[MAXN*4];
void push_up(int x)
{
    if(segTree[x].l==segTree[x].r)return;
    int lson=2*x;
    int rson=2*x+1;

    segTree[x].Lmax=segTree[lson].Lmax;
    if(segTree[lson].Lmax==segTree[lson].r-segTree[lson].l+1)segTree[x].Lmax+=segTree[rson].Lmax;
    segTree[x].Rmax=segTree[rson].Rmax;
    if(segTree[rson].Rmax==segTree[rson].r-segTree[rson].l+1)segTree[x].Rmax+=segTree[lson].Rmax;
    segTree[x].Max=max(segTree[lson].Max,segTree[rson].Max);
    segTree[x].Max=max(segTree[x].Max,max(segTree[x].Lmax,segTree[x].Rmax));
    segTree[x].Max=max(segTree[x].Max,segTree[lson].Rmax+segTree[rson].Lmax);

    segTree[x].Lmax1=segTree[lson].Lmax1;
    if(segTree[lson].Lmax1==segTree[lson].r-segTree[lson].l+1)segTree[x].Lmax1+=segTree[rson].Lmax1;
    segTree[x].Rmax1=segTree[rson].Rmax1;
    if(segTree[rson].Rmax1==segTree[rson].r-segTree[rson].l+1)segTree[x].Rmax1+=segTree[lson].Rmax1;
    segTree[x].Max1=max(segTree[lson].Max1,segTree[rson].Max1);
    segTree[x].Max1=max(segTree[x].Max1,max(segTree[x].Lmax1,segTree[x].Rmax1));
    segTree[x].Max1=max(segTree[x].Max1,segTree[lson].Rmax1+segTree[rson].Lmax1);
}
void push_down(int x)
{
    if(segTree[x].l==segTree[x].r)return;
    int lson=2*x,rson=2*x+1;
    if(segTree[x].Max==0)
    {
        segTree[lson].Max=segTree[lson].Lmax=segTree[lson].Rmax=0;
        segTree[rson].Max=segTree[rson].Lmax=segTree[rson].Rmax=0;
    }
    if(segTree[x].Max==segTree[x].r-segTree[x].l+1)
    {
        segTree[lson].Max=segTree[lson].Lmax=segTree[lson].Rmax=segTree[lson].r-segTree[lson].l+1;
        segTree[rson].Max=segTree[rson].Lmax=segTree[rson].Rmax=segTree[rson].r-segTree[rson].l+1;
    }


    if(segTree[x].Max1==0)
    {
        segTree[lson].Max1=segTree[lson].Lmax1=segTree[lson].Rmax1=0;
        segTree[rson].Max1=segTree[rson].Lmax1=segTree[rson].Rmax1=0;
    }
    if(segTree[x].Max1==segTree[x].r-segTree[x].l+1)
    {
        segTree[lson].Max1=segTree[lson].Lmax1=segTree[lson].Rmax1=segTree[lson].r-segTree[lson].l+1;
        segTree[rson].Max1=segTree[rson].Lmax1=segTree[rson].Rmax1=segTree[rson].r-segTree[rson].l+1;
    }

}
void Build(int i,int l,int r)
{
    segTree[i].l=l;
    segTree[i].r=r;
    segTree[i].Max=segTree[i].Lmax=segTree[i].Rmax=r-l+1;
    segTree[i].Max1=segTree[i].Lmax1=segTree[i].Rmax1=r-l+1;
    if(l==r)return;
    int mid=(l+r)/2;
    Build(i<<1,l,mid);
    Build((i<<1)|1,mid+1,r);
}
int query(int i,int x)
{
    if(segTree[i].Max<x)return 0;
    if(segTree[i].Lmax>=x)return segTree[i].l;
    if(segTree[i<<1].Max>=x)return query(i<<1,x);
    if(segTree[i<<1].Rmax+segTree[(i<<1)|1].Lmax>=x)return segTree[i<<1].r-segTree[i<<1].Rmax+1;
    return query((i<<1)|1,x);
}
int query1(int i,int x)
{
    if(segTree[i].Max1<x)return 0;
    if(segTree[i].Lmax1>=x)return segTree[i].l;
    if(segTree[i<<1].Max1>=x)return query1(i<<1,x);
    if(segTree[i<<1].Rmax1+segTree[(i<<1)|1].Lmax1>=x)return segTree[i<<1].r-segTree[i<<1].Rmax1+1;
    return query1((i<<1)|1,x);
}
void update(int i,int l,int r)
{
    if(segTree[i].l==l && segTree[i].r==r)
    {
        segTree[i].Max=segTree[i].Lmax=segTree[i].Rmax=segTree[i].r-segTree[i].l+1;
        segTree[i].Max1=segTree[i].Lmax1=segTree[i].Rmax1=segTree[i].r-segTree[i].l+1;
        return;
    }
    push_down(i);
    int mid=(segTree[i].l+segTree[i].r)/2;
    if(r<=mid)update(i<<1,l,r);
    else if(l>mid) update((i<<1)|1,l,r);
    else
    {
        update(i<<1,l,mid);
        update((i<<1)|1,mid+1,r);
    }
    push_up(i);
}
void zhan1(int i,int l,int r)
{
    if(segTree[i].l==l && segTree[i].r==r)
    {
        segTree[i].Max=segTree[i].Lmax=segTree[i].Rmax=0;
        return;
    }
    push_down(i);
    int mid=(segTree[i].l+segTree[i].r)/2;
    if(r<=mid)zhan1(i<<1,l,r);
    else if(l>mid) zhan1((i<<1)|1,l,r);
    else
    {
        zhan1(i<<1,l,mid);
        zhan1((i<<1)|1,mid+1,r);
    }
    push_up(i);
}
void zhan2(int i,int l,int r)
{
    if(segTree[i].l==l && segTree[i].r==r)
    {
        segTree[i].Max=segTree[i].Lmax=segTree[i].Rmax=0;
        segTree[i].Max1=segTree[i].Lmax1=segTree[i].Rmax1=0;
        return;
    }
    push_down(i);
    int mid=(segTree[i].l+segTree[i].r)/2;
    if(r<=mid)zhan2(i<<1,l,r);
    else if(l>mid) zhan2((i<<1)|1,l,r);
    else
    {
        zhan2(i<<1,l,mid);
        zhan2((i<<1)|1,mid+1,r);
    }
    push_up(i);
}

int main()
{
//    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
    int T;
    int n,m;
    int l,r;
    int x;
    char op[20];
    scanf("%d",&T);
    int iCase=0;
    while(T--)
    {
        iCase++;
        printf("Case %d:\n",iCase);
        scanf("%d%d",&n,&m);
        Build(1,1,n);
        while(m--)
        {
            scanf("%s",op);
            if(op[0]=='D')
            {
                scanf("%d",&x);
                int tmp=query(1,x);
                if(tmp==0)printf("fly with yourself\n");
                else
                {
                    zhan1(1,tmp,tmp+x-1);
                    printf("%d,let's fly\n",tmp);
                }
            }
            else if(op[0]=='N')
            {
                scanf("%d",&x);
                int tmp=query(1,x);
                if(tmp!=0)
                {
                    zhan2(1,tmp,tmp+x-1);
                    printf("%d,don't put my gezi\n",tmp);
                    continue;
                }
                tmp=query1(1,x);
                if(tmp!=0)
                {
                    zhan2(1,tmp,tmp+x-1);
                    printf("%d,don't put my gezi\n",tmp);
                    continue;
                }
                printf("wait for me\n");
            }
            else
            {
                scanf("%d%d",&l,&r);
                printf("I am the hope of chinese chengxuyuan!!\n");
                update(1,l,r);
            }
        }
    }
    return 0;
}