Tunnel Warfare HDU

During the War of Resistance Against Japan, tunnel warfare was carried out extensively in the vast areas of north China Plain. Generally speaking, villages connected by tunnels lay in a line. Except the two at the ends, every village was directly connected with two neighboring ones.

Frequently the invaders launched attack on some of the villages and destroyed the parts of tunnels in them. The Eighth Route Army commanders requested the latest connection state of the tunnels and villages. If some villages are severely isolated, restoration of connection must be done immediately! 

InputThe first line of the input contains two positive integers n and m (n, m ≤ 50,000) indicating the number of villages and events. Each of the next m lines describes an event. 

There are three different events described in different format shown below: 

D x: The x-th village was destroyed. 

Q x: The Army commands requested the number of villages that x-th village was directly or indirectly connected with including itself. 

R: The village destroyed last was rebuilt. 
OutputOutput the answer to each of the Army commanders’ request in order on a separate line.
Sample Input

7 9
D 3
D 6
D 5
Q 4
Q 5
R
Q 4
R
Q 4

Sample Output

1
0
2
4

题意：有一排相互连接的村庄，给定三个操作，D表示摧毁第x个村庄，R表示修复上一个被摧毁的村庄，Q表示查询于第x个
村庄相连接的村庄数量，注意输入数据有多组。

思路：可以看出这个题时线段树的模板题，像摧毁操作和恢复操作都可以用线段树来轻松实现，但比较难的是查询连通的数量。首先我们可以转换一下思路，求这个连通的数量最简单的不就是找与这个村庄相连的最右边的和最左边的村庄吗，
转换一下就是求这个村庄于起点1之间的一个最大值和这个个村庄与终点m之间的一个最小值。然后就有了一个奇妙的想法，假如我们给定所有村庄的最小值为一个比较大的数（比如m+1），然后最大值为0，在摧毁村庄时把这两个值变为它自
己的编号，这样求连通区间的最右边就是被摧毁的最小值，最左边就是被摧毁的最大值啦。这样连通的问题就被解决了，最后要注意mi-ma+1，和恢复的是上一个被摧毁的村庄，应当开一个数组保存被摧毁的顺序。

代码：

#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#include <iostream>
#define mod 998244353
#define eps 1e-6
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;

const int maxn=500000;
int m,n;
struct node
{
    //l表示左边，r表示右边
    int li,ri;
    int mi,ma;
};
node no[maxn];
//初始化,k表示当前节点的编号，l表示当前区间的左边界，
void build(int k,int l,int r)
{
    no[k].li=l;
    no[k].ri=r;
    //如果递归到最低点
    if(l==r)
    {
        no[k].mi=m+1;
        no[k].ma=0;
        return ;
    }
    //对半分
    int mid=(l+r)/2;
    //递归到左线段
    build(k*2,l,mid);
    //递归到右线段
    build(k*2+1,mid+1,r);
    //更新当前节点的值
    no[k].mi=min(no[k*2].mi,no[k*2+1].mi);
    no[k].ma=max(no[k*2].ma,no[k*2+1].ma);
}

//单点修改,指定坐标x的值修改为y
void singlemodify(int k,int x,int y)
{
    if(no[k].li==no[k].ri)
    {
        no[k].mi=y;
        no[k].ma=y;
        return ;
    }
    int mid = (no[k].li+no[k].ri)/2;
    if(x<=mid)
    {
        singlemodify(k*2,x,y);
    }
    else
    {
        singlemodify(k*2+1,x,y);
    }
    //维护线段树
    no[k].mi=min(no[k*2].mi,no[k*2+1].mi);
    no[k].ma=max(no[k*2].ma,no[k*2+1].ma);
}
//恢复指定坐标的值,
void recovery(int k,int x)
{
    if(no[k].li==no[k].ri)
    {
        no[k].mi=m+1;
        no[k].ma=0;
        return ;
    }
    int mid = (no[k].li+no[k].ri)/2;
    if(x<=mid)
    {
        recovery(k*2,x);
    }
    else
    {
        recovery(k*2+1,x);
    }
    //维护线段树
    no[k].mi=min(no[k*2].mi,no[k*2+1].mi);
    no[k].ma=max(no[k*2].ma,no[k*2+1].ma);
}

//区间最值,flag为1时表示最小，为0时表示最大
int querymaxin(int k,int l,int r,int flag)
{
    //到对应层时返回值
    if(no[k].li==l&&no[k].ri==r)
    {
        if(flag==1)
        {
            return no[k].mi;
        }
        else
        {
            return no[k].ma;
        }
    }
    //取中值
    int mid=(no[k].li+no[k].ri)/2;
    if(r<=mid)
    {
        return querymaxin(k*2,l,r,flag);
    }
    else if(l>mid)
    {
        return querymaxin(k*2+1,l,r,flag);
    }
    else
    {
        if(flag==1)
        {
            return min(querymaxin(k*2,l,mid,flag),querymaxin(k*2+1,mid+1,r,flag));
        }
        else
        {
            return max(querymaxin(k*2,l,mid,flag),querymaxin(k*2+1,mid+1,r,flag));
        }

    }
}

int main()
{
    while(scanf("%d %d",&m,&n)!=EOF)
    {
        build(1,1,m);
        //记录毁掉的村庄的编号
        int history[50000];
        int ans=0;
        while(n--)
        {
            char ch[2];
            int s;
            cin>>ch;
            if(ch[0]=='D')
            {
                scanf("%d",&history[ans]);
                singlemodify(1,history[ans],history[ans]);
                ans++;
            }
            else if(ch[0]=='Q')
            {
                cin>>s;
                int mi = querymaxin(1,s,m,1);
                int ma = querymaxin(1,1,s,0);
                if(mi==ma)
                {
                    printf("0
");
                }
                else
                {
                    //记得要减一
                    printf("%d
",mi-ma-1);
                }
            }
            else if(ch[0]=='R')
            {
                ans--;
                recovery(1,history[ans]);
            }
        }
    }
}