ZOJ 3261 Connections in Galaxy War（并查集）

Description：

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 integersp0, 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

题意：有 N 个星球 ，编号从 0 到 n-1

      每个星球相应有一个能量值。

      在星际大战前 ，这 N 个星球间修建了 M 条边。

      相联系的星球间可以相互求助

      注意：各个星球只像能量值比自己大的星球求助，而且是尽量找到最大能量值的星球求助。

            如果有多个能量值一样的星球可以求助，则找编号小的。

      给出 Q 个操作 ：

                     query X 表示编号为 X 的星球想要求助，如果有满足的星球，则输出求助的编号，否则输出 -1

                     destroy  X  Y 表示破坏了 X 和 Y之间的联系【注意】：保证破坏的一定是前面已经建立了联系的边。

思路总结：还是用并查集确定关系【简单】

                    重要的是无法判断 query 时哪些星球已经建立了联系？

 解决方法：输入时记录每一条边

                    记录每一个操作和销毁的边。

                    输入结束后先用并查集加入所有没有被销毁的边

                    然后再逆序操作记录结果，此时遇到 destroy 则加入销毁的边 ，遇到 query 直接查找即可。

                    最终逆序输出结果。注意：不同的测试数据有空行。

重点：如何标记边是否使用，盗版了大神的 STL 用 map 标记边，用 used[] 标记是否使用具体看代码。
 

AC代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
const int maxn = 10000+10;

int p[maxn]; // 父节点
int fre[maxn]; //能量值
bool vis[20005]; //标记边是否使用
map<int,int>mp[maxn]; //记录边
struct Edge
{
    int u, v;
} edge[20005]; //建立的边

struct Node
{
    int op;
    int u,v;
} node[50005]; //操作
int ans[50005]; //结果

int find(int x)
{
    return p[x] == x ? x : p[x] = find(p[x]);
}

void Union(int x,int y)//能量大的为父; 能量一样，编号小的为父
{
    int fx=find(x);
    int fy=find(y);
    if(fre[fx]>fre[fy])
        p[fy]=fx;
    else if(fre[fx]==fre[fy])
    {
        if(fx <= fy)
            p[fy] = fx;
        else
            p[fx] = fy;
    }
    else p[fx]=fy;
}

int main()
{
    int n;
    bool flag = true;
    while(scanf("%d", &n) != EOF)
    {
        if(flag)
            flag=false;
        else
            printf("\n");

        for(int i = 0; i < n; i++)
        {
            scanf("%d", &fre[i]);
            p[i] = i;
            mp[i].clear(); //清空 可减少一半内存
        }
        int m;
        int u,v;
        scanf("%d",&m);
        for(int i = 0; i < m; i++)
        {
            scanf("%d %d", &u, &v);
            if(u > v)
                swap(u,v);
            edge[i].u=u;
            edge[i].v=v;
            mp[u][v]=i;
            vis[i]=false; //标记未使用的边
        }
        int Q;
        char str[10];
        scanf("%d",&Q);
        for(int i = 0; i < Q; i++)
        {
            scanf("%s", str);
            if(str[0] == 'q')
            {
                node[i].op = 0;
                scanf("%d",&node[i].u);
            }
            else if(str[0]=='d')
            {
                node[i].op=1;
                scanf("%d %d", &u, &v);
                if(u > v)
                    swap(u, v);
                node[i].u = u;
                node[i].v = v;
                int tmp=mp[u][v];
                vis[tmp]=true;//标记销毁了的边
            }
        }
        for(int i = 0; i < m; i++) //连接所有未被销毁的边
        {
            if(!vis[i])
                Union(edge[i].u,edge[i].v);
        }
        int cnt = 0;
        for(int i = Q-1; i >= 0; i--) //逆序操作
        {
            if(node[i].op==0)
            {
                int x=node[i].u;
                int fx=find(x);
                if(fre[fx]>fre[x])
                    ans[cnt++]=fx; //如果根节点能量较大
                else
                    ans[cnt++]=-1;
            }
            else if(node[i].op==1)
            {
                Union(node[i].u,node[i].v);
            }
        }
        for(int i = cnt-1; i >= 0; i--) //逆序输出结果
            printf("%d\n", ans[i]);
    }
    return 0;
}