L

题意：有一个帝国在打仗，敌方会搞一些破坏，总共用N个阵地，每个阵地都有一个武力值，当第一地方收到攻击的时候他可以进行求助，当然求助的对象只能是武力值比他高的，如果求助失败就输出 ‘-1’， 求助成功就输出 帮助对象的的下标，如果有多个相同武力值的阵地输出下标最小的那个。

输入的第一行是N，表示又N个阵地（0到n-1），下面一行输入每个阵地的武力值，接着输入一个M，下面有M行，表示两点可以想通，接着有Q次查询，query 是查询这个点能不能有帮助他的，destroy表示摧毁两点之间的联系，值得注意的是，他所摧毁的一定是存在的路，而输入的时候也没有重复数据（为了是题目简单一些吧）。

分析：由于是中间有摧毁的步骤，而并查集只能两点链接，不能消除，所以只能倒着处理数据，先把所有能摧毁的全部都不链接，把没有摧毁的链接起来，（可以用扩大第二个数的办法来快速查找路），倒着读的时候遇到摧毁就进行建立，这样可以了，不过还要注意值相等的时候按照下标，就是忘了这点才错了好几次，而且数据之间输出一个空行

////////////////////////////////////////////////////////////////

 #include<iostream>

#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<string.h>
#include<queue>
#include<stack>
using namespace std;

const int maxn = 20005;
const int BigNum = 10000;

struct node
{
    int op, u, v;//op等于1代表查询，等于0代表摧毁
}data[maxn*3];//保存查询数据

int f[maxn], val[maxn];
//为了方便查询，把x值扩大10w倍+y值保存下来,use记录这个路是否被摧毁
int h[maxn], use[maxn];

int Find(int x)
{
    if(f[x] != x)
        f[x] = Find(f[x]);
    return f[x];
}
void Union(int u, int v)
{
    u = Find(u), v = Find(v);

    if(u != v)
    {
        if(val[u] < val[v])
            f[u] = v;
        else if(val[u] > val[v])//写成了两个一样的。。。。
            f[v] = u;
        else if(u < v)
            f[v] = u;
        else
            f[u] = v;
    }
}

int main()
{
    int N, t=0;

    while(scanf("%d", &N) != EOF)
    {
        int i, M, u, v, Q;
        char s[10];

        for(i=0; i<N; i++)
        {
            f[i] = i;
            scanf("%d", &val[i]);
        }

        scanf("%d", &M);

        for(i=0; i<M; i++)
        {
            scanf("%d%d", &u, &v);
            if(u > v)swap(u, v);
            h[i] = u + v*BigNum;
            use[i] = 0;
        }

        sort(h, h+M);

        scanf("%d", &Q);

        for(i=0; i<Q; i++)
        {
            scanf("%s", s);

            if(s[0] == 'd')
            {
                scanf("%d%d", &u, &v);

                if(u > v)swap(u, v);
                data[i].u = u;data[i].v = v;
                data[i].op = 0;
                int k = lower_bound(h, h+M, u+v*BigNum) - h;
                use[k] = 1;
            }
            else
            {
                scanf("%d", &u);
                data[i].op = 1, data[i].u = u;
            }
        }

        for(i=0; i<M; i++)
        {
            u = h[i] % BigNum, v = h[i] / BigNum;
            if(use[i] == 0)
                Union(u, v);
        }

        stack<int>sta;

        for(i=Q-1; i>=0; i--)
        {
            if(data[i].op == 0)
                Union(data[i].u, data[i].v);
            else
            {
                u = Find(data[i].u);

                if(val[u] <= val[data[i].u])
                    sta.push(-1);
                else
                    sta.push(u);
            }
        }

        if(t++)printf("
");
        while(sta.size())
        {
            printf("%d
", sta.top());
            sta.pop();
        }
    }

    return 0;
}
/*
5
1 2 3 4 5
4
0 1
1 2
2 3
3 4
5
query 0
query 1
query 2
query 3
query 4
*/