ZOJ3261-Connections in Galaxy War-（逆向并查集+离线处理）

题意：

1.有n个星球，每个星球有一个编号（1-n）和一个能量值。

2.一开始将某些星球连通。

3.开战后有很多个操作，查询某个星球能找谁求救或者摧毁两颗星球之间的连通路径，使其不能连通。如果连通则可以相互求救，求救的对象要求能量比自己大并且在连通的星球中能量最大，如果能量最大的星球有多个，则找编号小的。

解题：

1.用并查集连通星球，把能量大的作为根节点，如果能量相同则把编号小的作为根节点，方便查询求救对象。

2.并查集没有断开的操作，把末态作为起始状态逆推。保存一开始的连通路径和开战后摧毁的连通路径，战争结束的状态作为起始状态，不连通被摧毁的连通路径。

 #include<stdio.h>
 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<math.h>
 #include<string>
 #include<map>
 #include<queue>
 #include<stack>
 #include<set>
 #define ll long long
 #define inf 0x3f3f3f3f
 using namespace std;

 int n,m,x,y,q;
 int par[];///父亲
 map<int,bool>mp;
 int ans[];
 struct star
 {
     int id;///编号
     int val;///能量值
 };star s[];

 struct edge
 {
     int x;
     int y;
 };edge e[];

 struct query
 {
     char s[];
     int x,y;

 };query que[];

 int find(int a)
 {
     if( par[a]==a )
         return a;
     return par[a]=find(par[a]);
 }

 void unit(int a,int b)
 {
     int aa=find(a);
     int bb=find(b);
     if(aa!=bb)
     {
         if( s[aa].val==s[bb].val )///相同能量值
         {
             if( s[aa].id<s[bb].id )///编号小的做根节点
                 par[bb]=aa;
             else
                 par[aa]=bb;
         }
         else if( s[aa].val<s[bb].val )///能量值大的作为根节点
             par[aa]=bb;
         else
             par[bb]=aa;
     }
 }

 int main()
 {
     bool first=true;
     while(scanf("%d",&n)!=EOF)///行星数量
     {
         if(first)///第一次进来变为false，以后每次都要打印空行
             first=false;
         else printf("\n");
         mp.clear();
         memset(ans,inf,sizeof(ans));
         for(int i=;i<n;i++)///能量值
         {
             scanf("%d",&s[i].val);
             s[i].id=i;
             par[i]=i;
         }
         scanf("%d",&m);///连通边
         for(int i=;i<m;i++)
         {
             scanf("%d%d",&x,&y);
             if(x>y)///保证x<y
                 swap(x,y);
             e[i].x=x;
             e[i].y=y;///存连通边
             mp[ x*+y ]=false;///没被毁掉
         }
         scanf("%d",&q);///查询
         for(int i=;i<q;i++)
         {
             getchar();
             scanf("%s",que[i].s);
             if(que[i].s[]=='q')
                 scanf("%d",&que[i].x);
             else
             {
                 scanf("%d %d",&x,&y);
                 if(x>y)///保证x<y
                     swap(x,y);
                 que[i].x=x;
                 que[i].y=y;
                 mp[ x*+y ]=true;///被毁掉
             }
         }
         ///离线处理
         for(int i=;i<m;i++)///把没被毁掉的边的末态作为起始态，逆推
         {
             x=e[i].x;
             y=e[i].y;
             if( !mp[ x*+y ] )
                 unit(x,y);
         }
         ///逆推,保存对应的答案
         for(int i=q-;i>=;i--)
         {
             if( que[i].s[]=='q' )
             {
                 x=find(que[i].x);///连通星球中 能量最大的 根星球
                 if( s[x].val>s[ que[i].x ].val )
                     ans[i]=s[x].id;
                 else
                     ans[i]=-;
             }
             else
                 unit( que[i].x,que[i].y );
         }
         ///顺序输出答案
         for(int i=;i<q;i++)
         {
             if(ans[i]!=inf)
                 printf("%d\n",ans[i]);
         }
     }
     return ;
 }