HDU - 约会安排(二维线段树区间合并)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4553
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)

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

Problem solving report:

Description: 一开始你有T时刻的空闲时间，有屌丝找你打游戏，女神找你约会和学习，让你根据首次适应安排时间。其中女神可以占用屌丝的时间。
Problem solving: 开2个线段树，第一个线段树用来存屌丝区间，第二个用女神区间，对于屌丝的请求，只要去更新查询第一个线段树， 对于女神的请求，先查询屌丝区间，如果有，那么把2个线段树上对应区间更新，如果没有，去女神线段树找，如果找到，更新2个线段树上相应区间(女神的级别高，所以可以无视屌丝线段树上被占用的区间，屌丝的级别低)
如果是清空(学习)，那么2个线段树都要去清空。

Accepted Code:

/* 
 * @Author: lzyws739307453 
 * @Language: C++ 
 */
#include <bits/stdc++.h>
using namespace std;
#define lson rt << 1
#define rson rt << 1 | 1
const int MAXN = 1e5 + 5;

//线段树维护的值
struct Tree {
    int val, ls, rs, laz;
    Tree() {}
    Tree(int v, int l) : val(v), ls(v), rs(v), laz(l) {}
}seg[2][MAXN << 2];

//建树
void Create(int l, int r, int tr, int rt) {
    seg[tr][rt] = Tree(r - l + 1, -1);
    if (!(r - l))
        return ;
    int mid = l + (r - l >> 1);
    Create(l, mid, tr, lson);
    Create(mid + 1, r, tr, rson);
}

//上推，区间合并维护最长连续区间
void Pushup(int l, int r, int tr, int rt) {
    int mid = l + (r - l >> 1);
    seg[tr][rt].ls = seg[tr][lson].ls;
    seg[tr][rt].rs = seg[tr][rson].rs;
    if (seg[tr][lson].ls > mid - l)
        seg[tr][rt].ls += seg[tr][rson].ls;
    if (seg[tr][rson].rs >= r - mid)
        seg[tr][rt].rs += seg[tr][lson].rs;
    seg[tr][rt].val = max(max(seg[tr][lson].val, seg[tr][rson].val), seg[tr][lson].rs + seg[tr][rson].ls);
}

//下压，将laz标记下放
void Pushdown(int l, int r, int tr, int rt) {
    if (~seg[tr][rt].laz) {
        int mid = l + (r - l >> 1);
        seg[tr][lson] = Tree(seg[tr][rt].laz * (mid - l + 1), seg[tr][rt].laz);
        seg[tr][rson] = Tree(seg[tr][rt].laz * (r - mid), seg[tr][rt].laz);
        seg[tr][rt].laz = -1;
    }
}

//更新
void Update(int Ql, int Qr, int v, int l, int r, int tr, int rt) {
    if (Ql <= l && Qr >= r) {
        seg[tr][rt] = Tree((r - l + 1) * v, v);
        return ;
    }
    Pushdown(l, r, tr, rt);
    int mid = l + (r - l >> 1);
    if (Ql <= mid)
        Update(Ql, Qr, v, l, mid, tr, lson);
    if (Qr > mid)
        Update(Ql, Qr, v, mid + 1, r, tr, rson);
    Pushup(l, r, tr, rt);
}

//查询满足连续区间>=len的区间左端点
int Query(int l, int r, int len, int tr, int rt) {
    if (!(r - l))
        return l;
    Pushdown(l, r, tr, rt);
    int mid = l + (r - l >> 1);
    //因为要尽量使符合要求的区间靠前，所以按左、中、右的顺序来查询
    if (seg[tr][lson].val >= len)
        return Query(l, mid, len, tr, lson);
    if (seg[tr][lson].rs + seg[tr][rson].ls >= len)
        return mid - seg[tr][lson].rs + 1;//如果是在左右子区间的后缀、前缀之间，则直接返回左区间的后缀最左值的下标
    return Query(mid + 1, r, len, tr, rson);
}

int main() {
    char op[10];
    int t, n, m, kase = 0;
    scanf("%d", &t);
    while (t--) {
        int x, y, l;
        scanf("%d%d", &n, &m);
        Create(1, n, 0, 1);//屌丝的请求建一个线段树
        Create(1, n, 1, 1);//女神的请求建一个线段树
        printf("Case %d:\n", ++kase);
        while (m--) {
            scanf(" %s%d", op, &x);
            if (op[0] != 'N') {
                if (op[0] != 'S') {
                    if (seg[0][1].val >= x) {//如果存在>=x的连续区间
                        l = Query(1, n, x, 0, 1);//得到符合要求区间的左端点下标
                        printf("%d,let's fly\n", l);
                        Update(l, l + x - 1, 0, 1, n, 0, 1);//更新屌丝树上的时间安排
                    }
                    else printf("fly with yourself\n");
                }
                else {
                    scanf("%d", &y);
                    printf("I am the hope of chinese chengxuyuan!!\n");
                    Update(x, y, 1, 1, n, 0, 1);//同时将屌丝树和女神树上的要求全部清除
                    Update(x, y, 1, 1, n, 1, 1);
                }
            }
            else {
                if (seg[0][1].val >= x) {//不用占用屌丝的时间也能和女神约会，即优先级低的屌丝树上也能满足(女神树上肯定也能满足)
                    l = Query(1, n, x, 0, 1);
                    printf("%d,don't put my gezi\n", l);
                    Update(l, l + x - 1, 0, 1, n, 0, 1);//更新屌丝树上时间安排
                    Update(l, l + x - 1, 0, 1, n, 1, 1);//女神树上也要更新同样一段，因为女神的要求之间优先级是相同的,如果有女神占了一段时间，那么其它女神也不能占用
                }
                else {
                    if (seg[1][1].val >= x) {//只要女神树上能满足，此时即使屌丝树上发生冲突也不管，需要占用基友时间，直接强制更新，体现了女神的高优先级
                        l = Query(1, n, x, 1, 1);
                        printf("%d,don't put my gezi\n", l);
                        Update(l, l + x - 1, 0, 1, n, 0, 1);
                        Update(l, l + x - 1, 0, 1, n, 1, 1);
                    }
                    else printf("wait for me\n");
                }
            }
        }
    }
    return 0;
}