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

https://cn.vjudge.net/problem/HDU-4553

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

分析

这里两类区间，屌丝区间和女神区间，给它们对应的标记，进行区间合并。

女神请求区间时，首先查询屌丝区间。若不行，再查询特别的女神区间，就相当于忽略了屌丝的存在。注意，在更新女神区间时，要同时更新屌丝区间。

至于要学习了，就直接区间清零。

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <string>

#include <algorithm>

#include <cmath>

#include <ctime>

#include <vector>

#include <queue>

#include <map>

#include <stack>

#include <set>

#include <bitset>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

#define ms(a, b) memset(a, b, sizeof(a))

#define pb push_back

#define mp make_pair

#define pii pair<int, int>

#define eps 0.0000000001

#define IOS ios::sync_with_stdio(0);cin.tie(0);

#define random(a, b) rand()*rand()%(b-a+1)+a

#define pi acos(-1)

const ll INF = 0x3f3f3f3f3f3f3f3fll;

const int inf = 0x3f3f3f3f;

const int maxn = 1e5 + ;

const int maxm =  + ;

const int mod = ;

struct ND{

    int l,r;

    int dl,dr,dm;

    int nl,nr,nm;

}tree[maxn<<];

int n,m;

void build(int rt,int l,int r){

    tree[rt].l=l,tree[rt].r=r;

    tree[rt].dl=tree[rt].dr=tree[rt].dm=r-l+;

    tree[rt].nl=tree[rt].nr=tree[rt].nm=r-l+;

    if(l==r) return;

    int mid = (l+r)>>;

    build(rt<<,l,mid);

    build(rt<<|,mid+,r);

}

void pushup(int rt){

//    if(tree[rt].l==tree[rt].r) return;

    int lson=rt<<,rson=rt<<|;

    tree[rt].dl=tree[lson].dl;

    if(tree[lson].dl==tree[lson].r-tree[lson].l+) tree[rt].dl+=tree[rson].dl;

    tree[rt].dr=tree[rson].dr;

    if(tree[rson].dr==tree[rson].r-tree[rson].l+) tree[rt].dr+=tree[lson].dr;

    tree[rt].dm=max(tree[lson].dm,tree[rson].dm);

    tree[rt].dm=max(tree[rt].dm,max(tree[rt].dl,tree[rt].dr));

    tree[rt].dm=max(tree[rt].dm,tree[lson].dr+tree[rson].dl);

    tree[rt].nl=tree[lson].nl;

    if(tree[lson].nl==tree[lson].r-tree[lson].l+) tree[rt].nl+=tree[rson].nl;

    tree[rt].nr=tree[rson].nr;

    if(tree[rson].nr==tree[rson].r-tree[rson].l+) tree[rt].nr+=tree[lson].nr;

    tree[rt].nm=max(tree[lson].nm,tree[rson].nm);

    tree[rt].nm=max(tree[rt].nm,max(tree[rt].nl,tree[rt].nr));

    tree[rt].nm=max(tree[rt].nm,tree[lson].nr+tree[rson].nl);

}

void pushdown(int rt){

//    if(tree[rt].l==tree[rt].r) return;

    int lson=rt<<,rson=rt<<|;

    if(tree[rt].dm==){

        tree[lson].dl=tree[lson].dr=tree[lson].dm=;

        tree[rson].dl=tree[rson].dr=tree[rson].dm=;

    }

    if(tree[rt].dm==tree[rt].r-tree[rt].l+){

        tree[lson].dl=tree[lson].dr=tree[lson].dm=tree[lson].r-tree[lson].l+;

        tree[rson].dl=tree[rson].dr=tree[rson].dm=tree[rson].r-tree[rson].l+;

    }

    if(tree[rt].nm==){

        tree[lson].nl=tree[lson].nr=tree[lson].nm=;

        tree[rson].nl=tree[rson].nr=tree[rson].nm=;

    }

    if(tree[rt].nm==tree[rt].r-tree[rt].l+){

        tree[lson].nl=tree[lson].nr=tree[lson].nm=tree[lson].r-tree[lson].l+;

        tree[rson].nl=tree[rson].nr=tree[rson].nm=tree[rson].r-tree[rson].l+;

    }

}

int d_query(int rt,int x){//为屌丝查询具有连续x的最小下标

    if(tree[rt].dm<x) return ;

    if(tree[rt].dl>=x) return tree[rt].l;

    if(tree[rt<<].dm>=x) return d_query(rt<<,x);

    if(tree[rt<<].dr+tree[rt<<|].dl>=x) return tree[rt<<].r-tree[rt<<].dr+;

    return d_query(rt<<|,x);

}

int n_query(int rt,int x){

    if(tree[rt].nm<x) return ;

    if(tree[rt].nl>=x) return tree[rt].l;

    if(tree[rt<<].nm>=x) return n_query(rt<<,x);

    if(tree[rt<<].nr+tree[rt<<|].nl>=x) return tree[rt<<].r-tree[rt<<].nr+;

    return n_query(rt<<|,x);

}

void s_update(int rt,int l,int r){

    if(l==tree[rt].l&&tree[rt].r==r){

        tree[rt].dl=tree[rt].dr=tree[rt].dm=tree[rt].r-tree[rt].l+;

        tree[rt].nl=tree[rt].nr=tree[rt].nm=tree[rt].r-tree[rt].l+;

        return;

    }

    pushdown(rt);

    int mid = (tree[rt].l+tree[rt].r)>>;

    if(r<=mid) s_update(rt<<,l,r);

    else if(l>mid) s_update(rt<<|,l,r);

    else{

        s_update(rt<<,l,mid);

        s_update(rt<<|,mid+,r);

    }

    pushup(rt);

}

void d_update(int rt,int l,int r){//学习时间更新

    if(l==tree[rt].l&&tree[rt].r==r){

        tree[rt].dl=tree[rt].dr=tree[rt].dm=;

        return;

    }

    pushdown(rt);

    int mid = (tree[rt].l+tree[rt].r)>>;

    if(r<=mid) d_update(rt<<,l,r);

    else if(l>mid) d_update(rt<<|,l,r);

    else{

        d_update(rt<<,l,mid);

        d_update(rt<<|,mid+,r);

    }

    pushup(rt);

}

void n_update(int rt,int l,int r){

    if(l==tree[rt].l&&tree[rt].r==r){

        tree[rt].dl=tree[rt].dr=tree[rt].dm=;

        tree[rt].nl=tree[rt].nr=tree[rt].nm=;

        return;

    }

    pushdown(rt);

    int mid = (tree[rt].l+tree[rt].r)>>;

    if(r<=mid) n_update(rt<<,l,r);

    else if(l>mid) n_update(rt<<|,l,r);

    else{

        n_update(rt<<,l,mid);

        n_update(rt<<|,mid+,r);

    }

    pushup(rt);

}

int main() {

#ifdef LOCAL

    freopen("in.txt", "r", stdin);

//    freopen("output.txt", "w", stdout);

#endif

    int T,cas=;

    scanf("%d",&T);

    while(T--){

        char op[];

        printf("Case %d:\n",cas++);

        scanf("%d%d",&n,&m);

        build(,,n);

        while(m--){

            scanf("%s",op);

            if(op[]=='D'){

                int x;

                scanf("%d",&x);

                int tmp=d_query(,x);

                if(!tmp) puts("fly with yourself");

                else{

                    d_update(,tmp,tmp+x-);

                    printf("%d,let's fly\n",tmp);

                }

            }else if(op[]=='N'){

                int x;

                scanf("%d",&x);

                int tmp=d_query(,x);

                if(tmp){

                    n_update(,tmp,tmp+x-);

                    printf("%d,don't put my gezi\n",tmp);

                }else{

                    tmp=n_query(,x);

                    if(tmp){

                        n_update(,tmp,tmp+x-);

                        printf("%d,don't put my gezi\n",tmp);

                    }else puts("wait for me");

                }

            }else{

                int x,y;

                scanf("%d%d",&x,&y);

                s_update(,x,y);

                puts("I am the hope of chinese chengxuyuan!!");

            }

        }

    }

    return ;

}

巴特西

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

分析

最新文章

热门文章