zoj 3261 Connections in Galaxy War

传送门。

In order to strengthen the defense ability, many stars in galaxy allied together and built many bidirectional tunnels to exchange messages. However, when the Galaxy War began, some tunnels were destroyed by the monsters from another dimension. Then many problems were raised when some of the stars wanted to seek help from the others.

In the galaxy, the stars are numbered from 0 to N-1 and their power was marked by a non-negative integer pi. When the star A wanted to seek help, it would send the message to the star with the largest power which was connected with star A directly or indirectly. In addition, this star should be more powerful than the star A. If there were more than one star which had the same largest power, then the one with the smallest serial number was chosen. And therefore, sometimes star A couldn't find such star for help.

Given the information of the war and the queries about some particular stars, for each query, please find out whether this star could seek another star for help and which star should be chosen.

Input

There are no more than 20 cases. Process to the end of file.

For each cases, the first line contains an integer N (1 <= N <= 10000), which is the number of stars. The second line contains N integers p0, p1, ... , pn-1 (0 <= pi <= 1000000000), representing the power of the i-th star. Then the third line is a single integer M (0 <= M <= 20000), that is the number of tunnels built before the war. Then M lines follows. Each line has two integers a, b (0 <= a, b <= N - 1, a != b), which means star a and star b has a connection tunnel. It's guaranteed that each connection will only be described once.

In the (M + 2)-th line is an integer Q (0 <= Q <= 50000) which is the number of the information and queries. In the following Q lines, each line will be written in one of next two formats.

"destroy a b" - the connection between star a and star b was destroyed by the monsters. It's guaranteed that the connection between star a and star b was available before the monsters' attack.

"query a" - star a wanted to know which star it should turn to for help

There is a blank line between consecutive cases.

Output

For each query in the input, if there is no star that star a can turn to for help, then output "-1"; otherwise, output the serial number of the chosen star.

Print a blank line between consecutive cases.

Sample Input

2
10 20
1
0 1
5
query 0
query 1
destroy 0 1
query 0
query 1

Sample Output

1
-1
-1
-1

【题意】

开始给你一个无向图，两个操作，一个是删边，一个是询问和之间接相连的点的最大权值是否大于当前结点，如果大于就输出权值最大的点的最小编号，否则输出-1.

【分析】

首先容易想到的是并查集来维护每一个集合，但是并查集不能删，只能加，所以怎么弄呢？

逆向并查集，我们先把左右的query离线下来，然后，从最后一个询问依次向前处理。如果某一个询问时删边，那么对于之前的询问就相当于是有这个边的，所以我们先删除所有询问里面的边，然后对于每个询问逆向处理，然后删边就成了加边，这样就符合并查集的性质了。

【代码】

#define change_input() freopen("C:\\Users\\ACM2018\\Desktop\\in.txt","r",stdin)
#include <bis/stdc++.h>
using namespace std;
const int maxm = 1e5;
int len;
int num[maxm];
struct p
{
    int que;
    int a,b;
}que[maxm*5];///离线出所有的询问
map<int,bool> mp;///判断某一个边是不是应该在初始的时候加进去
int query;///询问的数量
pair<int,int> edge[maxm<<1];///存下所有的边
int edge_num;///边的数量
char nouse[20];///用来处理读入询问，没什么卵作用
int pre[maxm];///并查集中的父节点
int ans[maxm];///用来统计每个节点对应的最大值
void init(void){
    for(int i = 1;i<=len;i++){
        pre[i] = i;
        ans[i] = num[i];
    }
}///并查集的初始化
int fin(int a){
    if(a==pre[a]) return a;
    int fat = fin(pre[a]);
    pre[a] = fat;
    ans[fat] = max(ans[fat],ans[a]);
    return pre[a];
}
void uni(int a,int b){
    int aa = fin(a);
    int bb = fin(b);
    if(aa==bb) return;
    if(ans[aa]<ans[bb]) swap(aa,bb),swap(a,b);
    if(ans[aa]==ans[bb]){
        if(aa>bb) swap(aa,bb);
        pre[bb] = aa;
        ans[aa] = max(ans[aa],ans[bb]);
    }
    else{
        pre[bb] = aa;
        ans[aa] = max(ans[aa],ans[bb]);
    }
}
int pri[maxm*5];///统计答案方便输出
int main() {
    //change_input();
    bool flag = false;
    while(scanf("%d",&len)!=EOF){
    if(flag) puts("");
    else flag = true;
    mp.clear();
    for(int i = 1;i<=len;i++) scanf("%d",num+i);
    init();
    scanf("%d",&edge_num);
    for(int i = 0;i<edge_num;i++){
        scanf("%d%d",&edge[i].first,&edge[i].second);
        edge[i].first++;
        edge[i].second++;
    }
    scanf("%d",&query);
    for(int i = 0;i<query;i++){
        scanf("%s",nouse);
        if(nouse[0]=='q'){
            que[i].que = 1;
            scanf("%d",&que[i].a);
            que[i].a++;///保证点的编号从1开始
        } else{
            que[i].que = 2;
            scanf("%d%d",&que[i].a,&que[i].b);
            que[i].a++;
            que[i].b++;
            mp[que[i].a*maxm+que[i].b] = true;
            mp[que[i].b*maxm+que[i].a] = true;
        }
    }
    for(int i = 0;i<edge_num;i++){
        if(mp[edge[i].first*maxm+edge[i].second]) continue;///如果初始的时候边是被删掉的，就不加进去
        uni(edge[i].first,edge[i].second);
    }
    for(int i = query-1;i>=0;i--){
        if(que[i].que==1){
            int now = fin(que[i].a);
            if(num[now]>num[que[i].a]) pri[i] = now-1;///注意前面我们将所有点的编号进行了+1
            else pri[i] = -1;
        } else{
            uni(que[i].a,que[i].b);
        }
    }
    for(int i = 0;i<query;i++){
        if(que[i].que==1){
            printf("%d\n",pri[i]);
        }
    }}
    return 0;
}