hdu 2871(区间合并)

题意：有n个未分配的单位内存，编号从1到n，四种操作，Reset表示让所有内存还原为未分配状态并输出Reset now，New a表示从左开始找第一个有连续a个未分配的单位内存拿去分配并输出起始内存编号，Free a表示第a个内存所在的分配出去的内存块还原为未分配状态并输出起始和终止内存编号，Get a表示输出第a个分配出去的内存块的起始内存编号。如果有不合法操作输出Reject + 操作名。
题解：明显需要用线段树维护左右端点延伸出去的和整个区间的连续未分配出去的内存长度。不过因为还要输出每个内存块的起始和终止位置，所以还要维护区间内分配出去的内存块的任务编号可以用第几个操作表示，未分配就是-1。然后把所有分配出去的内存块的起始内存编号都用set存起来，每次Get操作就直接找。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
using namespace std;
const int N = 50005;
int n, q, lenl[N << 2], lenr[N << 2], len[N << 2], flag[N << 2];
int st[N], en[N];
set<int> s;

void pushup(int k, int left, int right) {
    int mid = (left + right) / 2;
    lenl[k] = lenl[k * 2];
    lenr[k] = lenr[k * 2 + 1];
    len[k] = max(len[k * 2], len[k * 2 + 1]);
    if (lenl[k * 2] == mid - left + 1)
        lenl[k] += lenl[k * 2 + 1];
    if (lenr[k * 2 + 1] == right - mid)
        lenr[k] += lenr[k * 2];
    len[k] = max(len[k], max(lenl[k], lenr[k]));
    len[k] = max(len[k], lenr[k * 2] + lenl[k * 2 + 1]);
}

void pushdown(int k, int left, int right) {
    if (flag[k]) {
        flag[k * 2] = flag[k * 2 + 1] = flag[k];
        if (flag[k] > 0) {
            len[k * 2] = lenl[k * 2] = lenr[k * 2] = 0;
            len[k * 2 + 1] = lenl[k * 2 + 1] = lenr[k * 2 + 1] = 0;
        }
        else {
            int mid = (left + right) / 2;
            len[k * 2] = lenl[k * 2] = lenr[k * 2] = mid - left + 1;
            len[k * 2 + 1] = lenl[k * 2 + 1] = lenr[k * 2 + 1] = right - mid;
        }
        flag[k] = 0;
    }
}

void build(int k, int left, int right) {
    flag[k] = 0;
    lenl[k] = lenr[k] = len[k] = right - left + 1;
    if (left == right) {
        flag[k] = -1;
        return;
    }
    int mid = (left + right) / 2;
    build(k * 2, left, mid);
    build(k * 2 + 1, mid + 1, right);
}

void modify(int k, int left, int right, int l, int r, int v) {
    if (l <= left && right <= r) {
        if (v > 0) {
            flag[k] = v;
            len[k] = lenl[k] = lenr[k] = 0;
        }
        else {
            flag[k] = v;
            len[k] = lenl[k] = lenr[k] = right - left + 1;
        }
        return;
    }
    pushdown(k, left, right);
    int mid = (left + right) / 2;
    if (l <= mid)
        modify(k * 2, left, mid, l, r, v);
    if (r > mid)
        modify(k * 2 + 1, mid + 1, right, l, r, v);
    pushup(k, left, right);
}

int query(int k, int left, int right, int v) {
    if (left == right)
        return left;
    pushdown(k, left, right);
    int mid = (left + right) / 2, res;
    if (len[k * 2] >= v)
        res = query(k * 2, left, mid, v);
    else if (lenr[k * 2] + lenl[k * 2 + 1] >= v)
        res = mid - lenr[k * 2] + 1;
    else res = query(k * 2 + 1, mid + 1, right, v);
    pushup(k, left, right);
    return res;
}

int Find(int k, int left, int right, int pos) {
    if (flag[k])
        return flag[k];
    int mid = (left + right) / 2;
    if (pos <= mid)
        return Find(k * 2, left, mid, pos);
    return Find(k * 2 + 1, mid + 1, right, pos);
}

int main() {
    while (scanf("%d%d", &n, &q) == 2) {
        build(1, 1, n);
        s.clear();
        int a;
        char op[10];
        for (int i = 1; i <= q; i++) {
            scanf("%s", op);
            if (op[0] != 'R')
                scanf("%d", &a);
            else {
                s.clear();
                modify(1, 1, n, 1, n, -1);
                printf("Reset Now\n");
                continue;
            }
            if (op[0] == 'N') {
                if (len[1] >= a) {
                    st[i] = query(1, 1, n, a);
                    printf("New at %d\n", st[i]);
                    en[i] = st[i] + a - 1;
                    modify(1, 1, n, st[i], en[i], i);
                    s.insert(st[i]);
                } else printf("Reject New\n");
            }
            else if (op[0] == 'F') {
                int temp = Find(1, 1, n, a);
                if (temp == -1)
                    printf("Reject Free\n");
                else {
                    s.erase(st[temp]);
                    printf("Free from %d to %d\n", st[temp], en[temp]);
                    modify(1, 1, n, st[temp], en[temp], -1);
                }
            }
            else {
                if (a <= s.size()) {
                    set<int>::iterator it = s.begin();
                    while (a > 1) {
                        a--;
                        it++;
                    }
                    printf("Get at %d\n", *it);
                } else printf("Reject Get\n");
            }
        }
        printf("\n");
    }
    return 0;
}