HDOJ1540 Tunnel Warfare 线段树区间合并

HDOJ 1540

题目大意：给定两个整数N，M, 其中N表示一共有N个村庄，M代表有M次操作，操作有以下：

1.    D x  销毁村庄x

2.    Q x  询问与村庄x相邻的村庄总数

3.    R     最近一次销毁的村庄得到重建

问题分析：

对于N个村庄，可以建立一颗线段树，维护最大连续区间长度，操作分析：

1. 在线段树上找到x节点，并将x节点“销毁”（村庄x被销毁），然后分别更新与x节点（村庄x）相关联的节点值（这里指左右连续区间的长度）
2. 对于询问操作，显然这里要求返回的是存在x的最大左右连续区间长度和
3. 将村庄x恢复（具体到重置线段的覆盖标志），并更新与村庄x相关联的最大连续区间和

具体实现：

对于有N个村庄，可以建立区间为[1, N]的线段树，维护最大连续区间长度，节点里有这些信息需要维护：最大左连续区间长度，最大右连续区间长度，总对大连续区间长度，覆盖标志，每次PushUp都要将左右子区间进行合并，加入lazy-tag优化时间复杂度（简单来说就是将更新延迟到下一次询问或者需要更新的时候），对于R操作，因为该操作的对象是最近一次销毁的村庄，因此在每一次 D x 操作以后就将 x 进栈，等到 R 操作时就将栈顶弹出，于是操作对象就转移到栈顶元素

代码：

#include <stack>
#include <cstdio>
using namespace std;

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

const int maxn = 50000;

char cmd[5];
stack <int> st;
int n, mNum, a;
int lsum[maxn*3], rsum[maxn*3], sum[maxn*3], cover[maxn*3];

int Max(int x, int y)
{
    return (x>y ? x:y);
}/* Max */

void BuildTree(int l, int r, int rt)
{
    cover[rt] = -1;
    lsum[rt] = rsum[rt] = sum[rt] = r-l+1;
    
    if (l == r)
        return ;
    
    int m = (l+r)>>1;
    BuildTree(lson);
    BuildTree(rson);
}/* BuildTree */

void PushDown(int rt, int k)
{
    if (cover[rt] != -1)
    {
        cover[rt<<1] = cover[rt<<1|1] = cover[rt];
        lsum[rt<<1] = rsum[rt<<1] = sum[rt<<1] = cover[rt] ? 0:k-(k>>1);
        lsum[rt<<1|1] = rsum[rt<<1|1] = sum[rt<<1|1] = cover[rt] ? 0:(k>>1);
        cover[rt] = -1;
    }
}/* PushDown */

int Query(int p, int l, int r, int rt)
{
    if (sum[rt]==0 || sum[rt]==r-l+1 || l==r)
        return sum[rt];
    
    PushDown(rt, r-l+1);
    
    int m = (l+r)>>1;
    if (p <= m)
    {
        if (p > m-rsum[rt<<1])
            return rsum[rt<<1]+Query(m+1, rson);
        else
            return Query(p, lson);
    }
    else
    {
        if (p <= m+lsum[rt<<1|1])
            return lsum[rt<<1|1]+Query(m, lson);
        else
            return Query(p, rson);
    }
}/* Query */

void PushUp(int rt, int k)
{   /* 左右子区间合并 */ 
    lsum[rt] = lsum[rt<<1];
    rsum[rt] = rsum[rt<<1|1];
    
    if (lsum[rt] == k-(k>>1))
        lsum[rt] += lsum[rt<<1|1];
    if (rsum[rt] == (k>>1))
        rsum[rt] += rsum[rt<<1];
    
    sum[rt] = Max(rsum[rt<<1]+lsum[rt<<1|1], Max(sum[rt<<1], sum[rt<<1|1]));
}/* PushUp */

void UpData(int p, int c, int l, int r, int rt)
{
    if (l == r)
    {
        lsum[rt] = rsum[rt] = sum[rt] = c ? 0:r-l+1;
        cover[rt] = c;
        
        return ;
    }/* End of If */
    
    PushDown(rt, r-l+1);
    
    int m = (l+r)>>1;
    if (p <= m)
        UpData(p, c, lson);
    else
        UpData(p, c, rson);
    
    PushUp(rt, r-l+1);
}/* UpData */

int main()
{
    while (~scanf("%d %d", &n, &mNum))
    {
        BuildTree(1, n, 1);
        
        while (!st.empty())
            st.pop();
        
        for (int i=1; i<=mNum; ++i)
        {
            scanf("%s", cmd);
            if (cmd[0] == 'Q')
            {
                scanf("%d", &a);
                printf("%d\n", Query(a, 1, n, 1));
            }
            else if (cmd[0] == 'D')
            {
                scanf("%d", &a);
                UpData(a, 1, 1, n, 1);
                st.push(a);
            }
            else
            {
                a = st.top();
                st.pop();
                UpData(a, 0, 1, n, 1);
            }
        }/* End of For */
    }/* End of While */    
    
    return 0;
}