牛客多校3-Operating on a Graph【dsu】

题意：

　　给定n个点m条边的无向图，每个点一开始代表一种集合，共有n个集合

　　之后给出q次操作，每次询问将指定一个集合Oi，将所有与该集合有相连边的其他集合并入集合Oi

　　问经过q次操作后所有点属于哪个集合

做法：

　　之前没怎么遇见过启发式合并的题，所以赛时做法只是遍历所有点

　　每次从搜到的指定集合中的点开始dfs搜子树来合并。

　　这种做法会导致超时和在dfs找并查集子树时内存超限。

　　赛后了解到这就是启发式合并的基本思想，小集合并入大集合中

　　每次直接对集合进行操作，然后把小集合拼接在大集合上

　　基本上就是个启发式合并的板子题了

CODE

#include <bits/stdc++.h>
#define dbg(x) cout << #x << "=" << x << endl
#define eps 1e-8
#define pi acos(-1.0)

using namespace std;
typedef long long LL;

const int inf = 0x3f3f3f3f;

template<class T>inline void read(T &res)
{
    char c;T flag=1;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}

namespace _buff {
    const size_t BUFF = 1 << 19;
    char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
    char getc() {
        if (ib == ie) {
            ib = ibuf;
            ie = ibuf + fread(ibuf, 1, BUFF, stdin);
        }
        return ib == ie ? -1 : *ib++;
    }
}

int qread() {
    using namespace _buff;
    int ret = 0;
    bool pos = true;
    char c = getc();
    for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
        assert(~c);
    }
    if (c == '-') {
        pos = false;
        c = getc();
    }
    for (; c >= '0' && c <= '9'; c = getc()) {
        ret = (ret << 3) + (ret << 1) + (c ^ 48);
    }
    return pos ? ret : -ret;
}

const int maxn = 8e5 + 7;

int t;
int n;
int fa[maxn];
int m;

int fid(int x) {
    return x == fa[x] ? x : fa[x] = fid(fa[x]);
}

// vector<int> g[maxn];

// void dfs(int x, int pre, int oo) {
//     if(head[x] > cnt || fa[fid(x)] != oo) {
//         return;
//     }
//     for ( int i = head[x]; i; i = nxt[i] ) {
//         int v = edge[i];
//         if(v == pre || fa[fid(x)] != oo) {
//             continue;
//         }
//         if(fa[v] == fa[x]) {
//             for(auto it : g[v]) {
//                 dfs(it, v, oo);
//             }
//         }
//         else {
            
//             int fidu = fid(x), fidv = fid(v);
//             //printf("fa[%d]:%d fa[%d]:%d
",x, fidu, fidv, fidv);
//             if(fidu != oo)
//                 continue;
//             fa[fidv] = fidu;
//             for(auto it : g[fidv]) {
//                 g[fidu].push_back(it);
//             }
//             //printf("2:fa[%d]:%d fa[%d]:%d
",x, fa[fidu], fidv, fa[fidv]);
//             //return;
//         }
//     }
// }

vector<int> g[maxn];

void merge(vector<int> & a, vector<int> & b)
{
    if (a.size() < b.size()) swap(a, b);
    for (auto & x: b) a.push_back(x);
}


int main()
{
    scanf("%d",&t);
    while(t--) {
        scanf("%d %d",&n, &m);
        int maxx = max(n, m);
        for ( int i = 0; i <= maxx; ++i ) {
            fa[i] = i;
            g[i].clear();
        }
        for ( int i = 1; i <= m; ++i ) {
            int u,v;
            scanf("%d %d",&u, &v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        int q;
        scanf("%d",&q);
        while (q--) {
            int x;
            scanf("%d", &x);
            if (fid(x) != x) continue;
            vector<int> tmp = g[x];
            g[x].clear();
            for (auto & v: tmp) {
                int u = fid(v);
                if (fid(u) == fid(x)) continue;
                merge(g[x], g[u]);
                fa[fid(u)] = fid(x);
            }
        }
        // for ( int i = 0; i <= n - 1; ++i ) {
        //     for(auto it : g[i]) {
        //         cout << it << ' ';
        //     }
        //     puts("");
        // }
        for ( int i = 0; i <= n - 1; ++i ) {
                printf("%d ",fid(i));
        }
        puts("");
    }    
    return 0;
}