poj 2892 Tunnel Warfare

http://poj.org/problem?id=2892

此代码在POJ上能过 在hdu上过不了

题目大意：

n个村庄相连  三种操作

D 摧毁一个村庄

Q 查询包括此村庄在内和此村庄直接和间接相连的村庄数

R 修复上一个被摧毁的村庄

Ttree 写的很烂呀

思路：

将摧毁的村庄插入二叉树中

每次询问 就查找它左边和右边最近被摧毁的村庄 就可以知道答案了

修复一个村庄 就把它在树中删除

代码及其注释：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#include<algorithm>
#include<stack>

using namespace std;

const int N=50010;
struct node
{
    int k;
    int l,r,f;
}mem[N];
int destroy[N];//是否被摧毁
int treehead,n;//头结点 和村庄个数
stack<int>str;//保存被摧毁的村庄
void RightTurn(int i)//右转
{
    int f=mem[i].f;
    int l=mem[i].l;
    if(f==-1)
    {
        mem[l].f=-1;
        treehead=l;
    }else
    {
        if(mem[f].l==i)
        mem[f].l=l;
        else
        mem[f].r=l;
        mem[l].f=f;
    }
    mem[i].l=mem[l].r;
    if(mem[l].r!=-1)
    mem[mem[l].r].f=i;
    mem[l].r=i;
    mem[i].f=l;
}
void LeftTurn(int i)//左转
{
    int f=mem[i].f;
    int r=mem[i].r;
    if(f==-1)
    {
        mem[r].f=-1;

        treehead=r;
    }else
    {
        if(mem[f].l==i)
        mem[f].l=r;
        else
        mem[f].r=r;
        mem[r].f=f;
    }
    mem[i].r=mem[r].l;
    if(mem[r].l!=-1)
    mem[mem[r].l].f=i;
    mem[r].l=i;
    mem[i].f=r;
}
void insert(int i,int k)//插入
{
    if(k<i)
    {
        if(mem[i].l!=-1)
        {
            insert(mem[i].l,k);
            if(mem[mem[i].l].k<mem[i].k)
            {
                RightTurn(i);
            }
        }else
        {
            mem[i].l=k;
            mem[k].f=i;
        }
    }else
    {
        if(mem[i].r!=-1)
        {
            insert(mem[i].r,k);
            if(mem[mem[i].r].k<mem[i].k)
            {
                LeftTurn(i);
            }
        }else
        {
            mem[i].r=k;
            mem[k].f=i;
        }
    }
}
void dele(int i,int k)//删除
{
    if(i<k)
    {
        dele(mem[i].r,k);
    }else if(i>k)
    {
        dele(mem[i].l,k);
    }else
    {
        int x=i;
        while(mem[x].l!=-1||mem[x].r!=-1)
        {
            if(mem[x].l!=-1)
            {
                RightTurn(x);
            }else
            {
                LeftTurn(x);
            }
        }
        if(mem[x].f==-1)
        {
            treehead=-1;return;
        }
        if(mem[mem[x].f].l==x)
        mem[mem[x].f].l=-1;
        if(mem[mem[x].f].r==x)
        mem[mem[x].f].r=-1;
    }
}
void LeastLeft(int i,int k,int *L)//求最近左被摧毁村庄
{
    if(i==-1)
    {
        return;
    }
    if(k<=i)
    {
        LeastLeft(mem[i].l,k,L);
    }else if(k>i)
    {
        *L=max(*L,i);
        LeastLeft(mem[i].r,k,L);
    }

}
void LeastRight(int i,int k,int *R)//求最近右被摧毁村庄
{
    if(i==-1)
    {
        return;
    }
    if(k<i)
    {
        *R=min(*R,i);
        LeastRight(mem[i].l,k,R);
    }else if(k>=i)
    {
        LeastRight(mem[i].r,k,R);
    }
}
void begin()//初始化一些内容
{
   while(!str.empty())
   str.pop();
   memset(destroy,0,sizeof(destroy));
   treehead=-1;
}
int main()
{
   int m;
   while(scanf("%d %d",&n,&m)!=EOF)
   {
       begin();
       char c;
       int i;
       for(int k=1;k<=m;++k)
       {
           getchar();
           scanf("%c",&c);
           if(c=='D')
           {
               scanf("%d",&i);
               mem[i].l=mem[i].r=-1;
               mem[i].k=k;
               if(treehead==-1)//如果树是空的
               {
                   treehead=i;
                   mem[i].f=-1;
               }else
               {
                   insert(treehead,i);//否则 插入
               }
               str.push(i);
               ++destroy[i];//记录
           }else if(c=='Q')
           {
               int ans,L,R;
               scanf("%d",&i);
               if(destroy[i]>0)//特殊情况
               {
                  ans=0;
               }else
               {
                   L=0;
                   LeastLeft(treehead,i,&L);
                   R=n+1;
                   LeastRight(treehead,i,&R);
                   ans=R-L-1;
               }
               printf("%d\n",ans);

           }else
           {
               if(str.empty())
               continue;
               dele(treehead,str.top());//删点 并记录
               --destroy[str.top()];
               str.pop();
           }
       }
   }
   return 0;
}