hdu 2871 Memory Control

http://acm.hdu.edu.cn/showproblem.php?pid=2871

　　这是要用线段树的一道模拟题，题意相当简单，就是模拟内存分配的操作。题目用到线段树【单点更新，单点查询，区间更新，查找区间】的功能。

　　New：寻找是否有大于指定长度的区间，并将区间染色，标记起始位置。

　　Free：查询单点值，如果已被占用，则删除该区间。

　　Get：查找第x个区间，并返回起始位置。

　　Reset：将区间清空。

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cassert>

using namespace std;

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

typedef vector<int> vi;
const int maxn = 50005;

vi start, end;
int cnt[maxn << 2], mark[maxn << 2], late[maxn << 2], left[maxn << 2], right[maxn << 2], mx[maxn << 2];

/*****以下是统计端点位置与个数的线段树*****/
void build(int l, int r, int rt){
    cnt[rt] = 0;
    if (l == r){
        return ;
    }
    int m = (l + r) >> 1;

    build(lson);
    build(rson);
}

void up1(int rt){
    cnt[rt] = cnt[rt << 1] + cnt[rt << 1 | 1];
}

void add1(int key, int p, int l, int r, int rt){
    if (l == r){
        //assert(l == p);
        cnt[rt] += key;
        return ;
    }
    int m = (l + r) >> 1;

    if (p <= m) add1(key, p, lson);
    else add1(key, p, rson);
    up1(rt);
}

int find1(int k, int l, int r, int rt){
    if (l == r){
        return l;
    }
    int m = (l + r) >> 1;

    //printf("%d %d %d   cnt %d\n", k, l, r, cnt[rt << 1]);
    if (cnt[rt << 1] >= k) return find1(k, lson);
    else return find1(k - cnt[rt << 1], rson);
}
/******************************************/


/*******以下是标记区间占用情况的线段树*******/
void up2(int rt, int len){
    int l = rt << 1;
    int r = rt << 1 | 1;

    mx[rt] = max(max(mx[l], mx[r]), left[r] + right[l]);
    if (left[l] == len - (len >> 1)) left[rt] = left[l] + left[r];
    else left[rt] = left[l];
    if (right[r] == (len >> 1)) right[rt] = right[r] + right[l];
    else right[rt] = right[r];
}

void down2(int rt, int len){
    if (late[rt] != -2){
        int l = rt << 1;
        int r = rt << 1 | 1;

        mark[l] = late[l] = late[rt];
        mark[r] = late[r] = late[rt];
        if (~late[rt]){
            mx[l] = left[l] = right[l] = 0;
            mx[r] = left[r] = right[r] = 0;
        }
        else{
            int m = len >> 1;

            mx[l] = left[l] = right[l] = len - m;
            mx[r] = left[r] = right[r] = m;
        }
        late[rt] = -2;
    }
}

void update2(int k, int L, int R, int l, int r, int rt){
    if (L <= l && r <= R){
        late[rt] = mark[rt] = k;
        if (~k){
            mx[rt] = left[rt] = right[rt] = 0;
        }
        else{
            mx[rt] = left[rt] = right[rt] = r - l + 1;
        }
        return ;
    }
    int m = (l + r) >> 1;

    down2(rt, r - l + 1);
    if (L <= m) update2(k, L, R, lson);
    if (m < R) update2(k, L, R, rson);
    up2(rt, r - l + 1);
    //printf("%d %d %d %d %d\n", l, r, rt, mx[rt], mx[5]);
}

int find2(int len, int l, int r, int rt){
    int m = (l + r) >> 1;
    int tl = rt << 1, tr = rt << 1 | 1;

    down2(rt, r - l + 1);
    if (len == r - l + 1) return l;
    if (mx[tl] >= len){
        return find2(len, lson);
    }
    else if (right[tl] + left[tr] >= len){
        return m - right[tl] + 1;
    }
    else{
        return find2(len, rson);
    }
}

int query(int x, int l, int r, int rt){
    if (l == r){
        //assert(x == l);
        return mark[rt];
    }
    int m = (l + r) >> 1;

    down2(rt, r - l + 1);
    if (x <= m) return query(x, lson);
    else return query(x, rson);
}
/******************************************/

void deal(int n, int m){
    char buf[10];
    int k;

    start.clear();
    end.clear();

    update2(-1, 1, n, 1, n, 1);
    build(1, n, 1);
    //puts("Built!");
    while (m--){
        scanf("%s", buf);
        if (!strcmp(buf, "Reset")){
            update2(-1, 1, n, 1, n, 1); // 重置区间
            while (cnt[1]){
                int t = find1(1, 1, n, 1);
                add1(-1, t, 1, n, 1); //清空计数器
            }
            puts("Reset Now");
        }
        else if (!strcmp(buf, "New")){
            scanf("%d", &k);
            if (mx[1] < k){
                puts("Reject New");
                continue;
            }

            int s = find2(k, 1, n, 1); // 查找满足要求的区间的起点
            int t = start.size();

            add1(1, s, 1, n, 1); // 起点位置的计数器加一
            //printf("ss %d %d\n", s, s + k - 1);
            update2(t, s, s + k - 1, 1, n, 1); //更新区间
            //printf("mx  %d\n", mx[1]);
            start.push_back(s);
            end.push_back(s + k - 1);
            printf("New at %d\n", s);
        }
        else if (!strcmp(buf, "Free")){
            scanf("%d", &k);

            int t = query(k, 1, n, 1); // 找到位置所属区间的标号
            //printf("tt %d\n", t);
            if (~t){
                //printf("s %d t %d\n", start[t], end[t]);
                update2(-1, start[t], end[t], 1, n, 1); // 删除区间
                add1(-1, start[t], 1, n, 1); // 起始位置的计数器减一
                printf("Free from %d to %d\n", start[t], end[t]);
            }
            else{
                puts("Reject Free");
            }
        }
        else if (!strcmp(buf, "Get")){
            scanf("%d", &k);
            if (cnt[1] < k){
                puts("Reject Get");
                continue;
            }

            printf("Get at %d\n", find1(k, 1, n, 1)); // 返回第k个区间的位置
        }
    }
    puts("");
}

int main(){
    int n, m;

    //freopen("in", "r", stdin);

    while (~scanf("%d%d", &n, &m)){
        deal(n, m);
    }

    return 0;
}

——written by Lyon