Connections in Galaxy War「并查集 + 思维」

Connections in Galaxy War

题目描述：

n 个点，对应的价值为val[i], m条双向边，q次询问，每次询问先输入一个op

• op = “query”，则输入一个x，找到与x直接相连或者间接相连的最大价值的点，如果没有比x的价值严格大的，就输出-1，否则就输出对应的点的下标，如果有多个点话，优先输出最小下标
• op = “destroy”，则输入x和y，并摧毁x和y之间的边

思路：

倒着并查集

先将所有的输入都存下来，将不曾出现在q次询问中的边直接用并查集连接起来，然后倒着进行那q次询问

连接的时候要注意，将价值最大的放在根节点！！！

这样找的根结点就是需要的那个点

如果是query，就判断x的点的根结点是不是他自己，还得是价值严格大于他自己的，不是的话就存下来根节点，是的话就存-1

如果是destory，就用并查集连接x和y

注意事项：

• 写emerge的时候，要把价值大的做为根节点，如果相同就把id小的做为根节点
• 注意下标是从0到n-1
• 注意询问的时候必须是严格大于
• 初始化要注意写
• 多组输入，除了最后一组数据以外，都需要在结束后输出一行换行

/*
Work by: Chelsea
Problem: 不知名屑题
Knowledge: 垃圾算法
Time: O(能过)
*/
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cmath>
#include<bitset>
#include<cstdio>
#include<string>
#include<vector>
#include<sstream>
#include<cstring>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<unordered_map>
using namespace std;

//#pragma GCC optimize("Ofast")
//#pragma GCC target("fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
//#pragma GCC optimize("unroll-loops")

#define eps 1e-8
#define endl '\n'
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define NMAX 1000 + 50
#define ls p<<1
#define rs p<<1|1
#define mod 998244353
#define lowbit(x) (x & (-x))
#define sz(s) (int)(s).size()
#define sd(n) scanf("%d",&n)
#define sdd(n,m) scanf("%d %d",&n,&m)
#define sl(n) scanf("%lld",&n)
#define sll(n,m) scanf("%lld %lld",&n,&m)
#define pd(n) printf("%d\n", (n))
#define pdd(n,m) printf("%d %d\n",n, m)
#define sddd(n,m,z) scanf("%d %d %d",&n,&m,&z)
#define slll(n,m,z) scanf("%lld %lld %lld",&n,&m,&z)
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
#define m_p(a,b) make_pair(a, b)
typedef  long long ll;
typedef pair <int,int> pii;
typedef unsigned long long ull;
//不开longlong见祖宗!
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}

//不改范围见祖宗!!!
#define MAX 300000 + 50
int n, m, k, op;
int x, y, z;
int l, r;
string s, t;

struct ran{
    string op;
    int x, y;
}tr[MAX];
int val[MAX];
int fa[MAX];
void init(){
    for(int i = 0; i <= n; ++i)fa[i] = i;
}
int getfa(int x){
    return x == fa[x] ? x : fa[x] = getfa(fa[x]);
}

inline void emerge(int x, int y){
    int xx = getfa(x);
    int yy = getfa(y);
    if(val[xx] > val[yy])fa[yy] = xx;
    else if(val[xx] < val[yy])fa[xx] = yy;
    else{
        if(xx < yy)fa[yy] = xx;
        else fa[xx] = yy;
    }
}

void work(){
    int qq = 0;
    while (sd(n) != EOF) {
        ++qq;
        if(qq != 1)cout<<endl;
        init();
        map<pair<int, int>, int>mp;
        for(int i = 0; i < n; ++i){
            sd(val[i]);
        }
        sd(k);
        vector<pair<int, int> >v;
        for(int i = 1; i <= k; ++i){
            cin>>x>>y;
            if(x > y)swap(x, y);
            v.push_back(m_p(x, y));
        }
        sd(m);
        for(int i = 1; i <= m; ++i){
            cin>>tr[i].op;
            if(tr[i].op[0] == 'q')sd(tr[i].x);
            else {
                sdd(tr[i].x, tr[i].y);
                if(tr[i].x > tr[i].y)swap(tr[i].x, tr[i].y);
                mp[m_p(tr[i].x, tr[i].y)] = 1;
            }
        }
        for(int i = 0; i < k; ++i){
            if(!mp.count(v[i])){
                emerge(v[i].first, v[i].second);
            }
        }
        vector<int>ans;
        for(int i = m; i >= 1; --i){
            if(tr[i].op[0] == 'q'){
                int p = getfa(tr[i].x);
                if(p == tr[i].x){
                    ans.push_back(-1);
                }
                else {
                    if(val[p] == val[tr[i].x])ans.push_back(-1);
                    else ans.push_back(p);
                }
            }
            else{
                emerge(tr[i].x, tr[i].y);
            }
        }
        for(int i = (int)ans.size() - 1; i >= 0; --i)cout<<ans[i]<<endl;
    }
}

int main(){
//    io;
//    int tt;cin>>tt;
//    for(int _t = 1; _t <= tt; ++_t){
//        printf("Case #%d: ", _t);
        work();
//    }
    return 0;
}
/*
 3
 20 20 20
 3
 1 2
 0 1
 0 2
 4
 query 1
 query 2
 destroy 1 2
 query 2
 
 -1
 -1
 -1
 
 
 3
 10 20 10
 2
 1 2
 0 1
 5
 query 0
 query 1
 query 2
 destroy 1 2
 query 2

 1
 -1
 1
 -1

 */