Codeforces 891 C Envy

题目大意

给定一个 $n$ 个点 $m$ 条边的连通的无向图，每条边有一个权值，可能有重边。给出 $q$ 组询问，一组询问给出 $k$ 条边，问是否存在一棵最小生成树包含这 $k$ 条边。

思路

这道题是我独立想出来的，并没有看题解。

先考虑只有一组询问的做法。
判断某些边是否在某个最小生成树里，比较容易想到的做法是 Kruskal 算法：
为了表述方便，将输入的 $m$ 条边构成的集合记做 $E$，将查询的 $k$ 条边构成的集合记做 $E_q$ 。
假设 $E$ 中的边的权值中不同的数共有 $c$ 个，从小到大依次为 $w_1, w_2, \dots, w_c$。
将所有「权值小于 $w_1$」 的边都插入并查集，然后再将 $E_q$ 所有权值等于 $w_1$ 的边逐个插入并查集，看是否有矛盾（即是否有某条边的端点在同一个连通分量的情况），若有矛盾则说明不存在满足条件的最小生成树。若无矛盾则将 $E$ 中权值在 $[w_1,w_2)$ 范围内的边插入并查集，再把 $E_q$ 中权值为 $w_2$ 的边插入并查集，看是否矛盾；这样依次检验下去，若始终无矛盾则说明存在满足条件的最小生成树。

再考虑如何将这个做法用到多组询问上。
不难想到可以将询问离线处理。将 $q$ 组询问中权值相等的边放在一起处理。假设当前检验的是询问中权值为 $w$ 的边（此时 $E$ 中权值小于 $w$ 边都已插入并查集），每次检验完某个询问中权值为 $w$ 的边之后，需要将这些边从并查集中删除。

在用并查集维护（动态）图的连通性时，需要如果需要支持删边操作，那么可以不采用路径压缩而只采用按秩合并；这样就使得删边操作很容易实现。而按秩合并可以保证一棵 $n$ 个点的树的高度为 $O(\log n)$，这样找到根节点的复杂度为 $O(\log n)$，而合并和删边都是 $O(1)$ 的；总复杂度为 $O(m\log m + K\log n)$，其中 $K =\sum_{1\le i\le q}k_i$ 。

用 cin cout 竟然 TLE 了。。。

#include <bits/stdc++.h>
using namespace std;

const int N = 5e5 + 5;
int par[N];
int rk[N];

int root(int x){
    while(x != par[x]) x = par[x];
    return x;
}

struct his{
    int u, rk1;
    int v, rk2;
};

void unite(int x, int y){
    if(rk[x] > rk[y])
        par[y] = x;
    else{
        par[x] = y;
        if(rk[x] == rk[y])
            ++rk[y];
    }
}


void divide(const his &x){
    par[x.u] = x.u;
    par[x.v] = x.v;
    rk[x.u] = x.rk1;
    rk[x.v] = x.rk2;
}


struct edge{
    int u, v, l;
}e[N];

int b[N];


his h[N];

struct qedge{
    int eid, qid;
}a[N];

bool cmp(int x, int y){
    return e[x].l < e[y].l;
}

bool cmp2(const qedge &x, const qedge &y){
    return e[x.eid].l < e[y.eid].l || (e[x.eid].l == e[y.eid].l && x.qid < y.qid); 
}


bool ans[N];



int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i++){
        int u, v, l;
        scanf("%d%d%d", &u, &v, &l);
        e[i] = {u, v, l};
        b[i] = i;
    }
    


    int q;
    scanf("%d", &q);
    int nqe = 0;
    for(int i = 0; i < q; i++){
        int k;
        scanf("%d", &k);
        for(int j = 0; j < k; j++){
            int x;
            scanf("%d", &x);
            a[nqe++] = {x, i};
        }
    }

    sort(a, a + nqe, cmp2);

    for(int i = 1; i <= n; i++)
        par[i] = i;

    sort(b + 1, b + m + 1, cmp);

    for(int i = 1, j = 0; i <= m && j < nqe; ){
        for(; e[b[i]].l < e[a[j].eid].l; i++){
            int r1 = root(e[b[i]].u);
            int r2 = root(e[b[i]].v);
            if(r1 != r2)
                unite(r1, r2);
        }

        for(; j < nqe && e[a[j].eid].l == e[b[i]].l; ){
            int sz = 0;
            for(int k = a[j].qid; a[j].qid == k && e[a[j].eid].l == e[b[i]].l; j++){
                if(ans[k]) continue;
                auto &x = e[a[j].eid];
                int r1 = root(x.u), r2 = root(x.v);
                if(r1 == r2)
                    ans[k] = 1;
                else{
                    h[sz++] = {r1, rk[r1], r2, rk[r2]};
                    unite(r1, r2);
                }
            }
            for(int i = sz - 1; i >= 0; i--){
                divide(h[i]);
            }
        }
    }

    for(int i = 0; i < q; i++)
        puts(ans[i] ? "NO" : "YES");
    return 0;
}

转载于:https://www.cnblogs.com/Patt/p/7856719.html