Tunnel Warfare HDU - 1540（线段树最长连续区间）

题意：

一条线上的点，D x是破坏这个点，Q x是表示查询以x所在的最长的连续的点的个数，R是恢复上一次破坏的点。

 

解析：

线段树结点 设置一个  lq记录区间左端点开始的最大连续个数，  rq 记录区间右端点开始的最大的连续个数

其它和原来一样即可

看代码吧。。。

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stack>
#include <queue>
#include <algorithm>
#include <cmath>
#define mem(a, b) memset(a, b, sizeof(a))
using namespace std;
const int maxn = , INF = 0x7fffffff;
typedef long long LL;
int a, b, x, y, ans;

struct node{
    int l, r, w, lq, rq;
}Node[maxn];

void build(int k, int ll, int rr)
{
    Node[k].l = ll, Node[k].r = rr;
    if(Node[k].l == Node[k].r)
    {
        Node[k].lq = Node[k].rq = Node[k].w = ;
        return;
    }
    int m = (ll + rr) / ;
    build(k*, ll, m);
    build(k*+, m+, rr);
    Node[k].lq = Node[k].rq = Node[k].w = Node[k*].w + Node[k*+].w;
}

void chp(int k)  //单点修改
{
    if(Node[k].l == Node[k].r)
    {
        Node[k].lq = Node[k].rq = Node[k].w = y;
        return;
    }
    int m = (Node[k].l + Node[k].r) / ;
    if(x <= m) chp(k*);
    else chp(k*+);
    Node[k].w = Node[k*].w + Node[k*+].w;
    Node[k].lq = Node[k*].lq;           //修改后初始化 父结点的最长连续左区间 为 左子结点的最长连续左区间
    Node[k].rq = Node[k*+].rq;         //父结点的最长连续右区间 为 右子结点的最长连续右区间
    if(Node[k*].lq == Node[k*].r - Node[k*].l + )  //如果左子结点的最长连续左区间 为整个区间的长度 那么父结点的最长连续左区间 应该 加上 右子结点的最长连续右区间
        Node[k].lq += Node[k*+].lq;
    if(Node[k*+].rq == Node[k*+].r - Node[k*+].l + ) // 同理
        Node[k].rq += Node[k*].rq;
}

void qinter(int k, int t)
{
    if(Node[k].l == Node[k].r || Node[k].w ==  || Node[k].w == Node[k].r - Node[k].l + ) //如果当前区间为单点、区间和为0、区间和为区间长度 那么就没必要往下搜了 返回即可
    {
        ans += Node[k].w;
        return;
    }
    int m = (Node[k].l + Node[k].r) / ;
    if(t <= m)   //如果t在左子树
    {
        if(t >= Node[k*].r - Node[k*].rq + )  //如果t大于左子树右区间的左端点 说明t在左子树的右区间内
        {
            ans += (Node[k*].rq + Node[k*+].lq);  //然后用左子树的最长连右区间 + 右子树的最长连续左区间
            return;
        }
        else
            qinter(k*, t);  //如果不在右区间 则向下搜
    }
    else //同理
    {
        if(t <= Node[k*+].l + Node[k*+].lq - )
        {
            ans += (Node[k*+].lq + Node[k*].rq);
            return;
        }
        else
            qinter(k*+, t);
    }
}

int main()
{
    int n, m;
    ans = ;
   while(~scanf("%d%d",&n,&m)){
        build(, , n);
        stack<int> G;
        getchar();
        for(int i=; i<m; i++)
        {
            char str[];
            scanf("%s",str);
            if(strcmp(str, "D") == )
            {
                scanf("%d",&x);
                G.push(x);
                y = ;
                chp();
            }
            else if(strcmp(str, "R") == )
            {
                x = G.top();
                G.pop();
                y = ;
                chp();
            }
            else if(strcmp(str, "Q") == )
            {
                scanf("%d",&x);
                ans = ;
                qinter(, x);
                printf("%d\n",ans);
            }

        }
   }
    return ;
}