Tunnel Warfare HDU - 1540（线段树区间合并）

链接;http://acm.hdu.edu.cn/showproblem.php?pid=1540
题意：对于区间[1, n]进行m个操作， 其中 ：

1. D x代表x节点被摧毁
2. Q x代表查询从x节点开始向左右共有多少个未被摧毁的连续节点
3. R 代表修复上一个被摧毁的节点

解题思路：用线段树表示区间连续长度， 其实和单点更新差不多， 用类似分治的思想解决（分治解决最大连续区间和），详情看代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <math.h>
#include <stack>

#define LL long long
#define lson ins<<1
#define rson ins<<1|1
#define mid (l+r)/2
using namespace std;

const int Max = 50050;

//类似与分治的思想， vl表示该区间从最左端开始最长连续区间的长度， vr为从最右端开始的最长连续区间的长度
//vm为以中间开始向两端的最长连续区间的长度， 于是对于该区间的上层区间，其中间的长度为...
struct Tree {
    int l, r, vl, vr, vm;

    Tree operator+(const Tree &s) {//分治的思想进行合并
        Tree ans;
        ans.l = l, ans.r = s.r;
        ans.vl = vl, ans.vr = s.vr;
        ans.vm = max(vm, s.vm);
        ans.vm = max(ans.vm, vr + s.vl);
        if (vl == r - l + 1)ans.vl += s.vl;
        if (s.vr == s.r - s.l + 1)ans.vr += vr;
        return ans;
    }
} tree[Max << 2];

inline void build(int l, int r, int ins) {
    tree[ins].l = l, tree[ins].r = r, tree[ins].vl = tree[ins].vr = tree[ins].vm = r - l + 1;//初始不管从哪个方向开始连续长度都为整个区间
    if (l == r) {
        return;
    } else {
        build(l, mid, lson);
        build(mid + 1, r, rson);
    }
}

inline void updata(int aim, int val, int ins) {
    int l = tree[ins].l, r = tree[ins].r;
    if (r == l) {
        if (val)tree[ins].vl = tree[ins].vr = tree[ins].vm = 1;
        else tree[ins].vl = tree[ins].vr = tree[ins].vm = 0;
    } else {
        if (aim <= mid)updata(aim, val, lson);
        else updata(aim, val, rson);
        tree[ins] = tree[lson] + tree[rson];

    }
}

inline int query(int aim, int ins) {
    int l = tree[ins].l, r = tree[ins].r;
    if (l == r || tree[ins].vm == 0 || tree[ins].vm == tree[ins].r - tree[ins].l + 1) {//整个区间都是0， 或者整个区间都连续，或者到了底部 查询结束
        return tree[ins].vm;
    } else if (aim <= mid) {
        if (aim >= tree[lson].r - tree[lson].vr + 1)return query(aim, lson) + query(mid + 1, rson);//判断区间分布，是否需要向下查询
        else return query(aim, lson);
    } else {
        if (aim <= tree[rson].l + tree[rson].vl - 1)return query(mid, lson) + query(aim, rson);//同样
        else return query(aim, rson);
    }
}

int main() {
    int n, m, i;
    stack<int> sta;
    char opera[3];
    while (~scanf("%d%d", &n, &m)) {
        while (!sta.empty())sta.pop();
        build(1, n, 1);
        for (int a = 1; a <= m; a++) {
            scanf("%s", opera);
            if (opera[0] == 'D') {
                scanf("%d", &i);
                sta.push(i);
                updata(i, 0, 1);
            } else if (opera[0] == 'Q') {
                scanf("%d", &i);
                printf("%d\n", query(i, 1));
            } else {
                i = sta.top();
                sta.pop();
                updata(i, 1, 1);
            }
        }
    }
    return 0;
}