Codeforces Round #446 (Div. 2) E. Envy 最小生成树（kruscal原理）（离线查询）

题意：

给定一个无向联通带权图，和 q 个查询，每个查询给定若干条边，问这若干条边是否在某一个最小生成树中

思路：

我首先想到的是对于每个查询中的边进行并查集操作，然后另外的边用kruscal方法生成最小生成树，但是这样的复杂度能达到  n²，不可行（然后就不会做了）

后来也是看了题解才知道的做法：

把q 个查询离线，然后利用kruscal算法的原理进行处理；

我们知道 kruscal算法是把边按权值排序，从最小的边开始，对点进行并查集操作，

这个过程如果遇到一条新的边后，我们用并查集查找的时候发现这条边连接的两个点为一个集合，说明两点间的最小距离（边权和）小于这条边的权值，那么这条边就一定不是最小生成树中的边

然后我们对q个查询中的给定的所有权值的边存起来，从小边开始：对于某一个查询，小于当前相关的边权的边已经进行了并查集操作，然后对于当前相关的边连接的两个点进行并查集查询是否位于同一个集合，若是相同，那么说明这一条边肯定不是最小生成树中的边；

详见代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<queue>
#include<stack>
#include<map>
#define PI acos(-1.0)
#define in freopen("in.txt", "r", stdin)
#define out freopen("out.txt", "w", stdout)

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 5e5 + 7, maxd = 670000 + 7, mod = 1e9 + 7;
const int INF = 0x7f7f7f7f;

struct node {
    vector<int> id;
    vector<pair<int,int> > q;
};
map<int, node> mp;

struct edge {
    int s, t, w;
}e[maxn];

bool ans[maxn];
int f[maxn] = {0}, size_[maxn];
int s[maxn];

int find_(int i) { return f[i] ? find_(f[i]) : i; }
int union_(int i, int j) {
    f[j] = i;
    size_[i] += size_[j];
    return j;
}

int merge_(int i, int j) {
    i = find_(i), j = find_(j);
    if(i == j) return 0;
    return size_[i] > size_[j] ? union_(i, j) : union_(j, i);
}

void split(int i) {
    size_[f[i]] -= size_[i];
    f[i] = 0;
}

int main() {

    int n, m, qnum, x, y;
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= m; ++i) {
        scanf("%d %d %d", &e[i].s, &e[i].t, &e[i].w);
        mp[e[i].w].id.push_back(i);
    }
    scanf("%d", &qnum);
    for(int i = 0; i < qnum; ++i) {
        scanf("%d", &x);
        while(x--) {
            scanf("%d", &y);
            mp[e[y].w].q.push_back({i,y});
        }
    }
    for(int i = 1; i <= n; ++i)
        size_[i] = 1;
    for(auto& p:mp) {
        auto& q = p.second.q;
        sort(q.begin(), q.end());
        int cnt = 0;
        for(int j = 0; j < q.size(); ++j) {
            int t = merge_(e[q[j].second].s, e[q[j].second].t);
            if(!t) ans[q[j].first] = true;
            else s[++cnt] = t;
            if(j+1 == q.size() || q[j].first != q[j+1].first) {
                while(cnt) split(s[cnt--]);
            }
        }
        for(int edge : p.second.id)
            merge_(e[edge].s, e[edge].t);
    }
    for(int i = 0; i < qnum; ++i)
        printf(ans[i] ? "NO\n" : "YES\n");

    return 0;
}