【蓝桥杯】网络分析（带权并查集）

小明正在做一个网络实验。

他设置了 n 台电脑，称为节点，用于收发和存储数据。

初始时，所有节点都是独立的，不存在任何连接。

小明可以通过网线将两个节点连接起来，连接后两个节点就可以互相通信了。

两个节点如果存在网线连接，称为相邻。

小明有时会测试当时的网络，他会在某个节点发送一条信息，信息会发送到每个相邻的节点，之后这些节点又会转发到自己相邻的节点，直到所有直接或间接相邻的节点都收到了信息。

所有发送和接收的节点都会将信息存储下来。

一条信息只存储一次。

给出小明连接和测试的过程，请计算出每个节点存储信息的大小。

输入格式
输入的第一行包含两个整数 n,m，分别表示节点数量和操作数量。

节点从 1 至 n 编号。

接下来 m 行，每行三个整数，表示一个操作。

如果操作为 1 a b，表示将节点 a 和节点 b 通过网线连接起来。当 a = b 时，表示连接了一个自环，对网络没有实质影响。
如果操作为 2 p t，表示在节点 p 上发送一条大小为 t 的信息。
输出格式
输出一行，包含 n 个整数，相邻整数之间用一个空格分割，依次表示进行完上述操作后节点 1 至节点 n 上存储信息的大小。

数据范围
1≤n≤10000,
1≤m≤10⁵,
1≤t≤100
输入样例1：
4 8
1 1 2
2 1 10
2 3 5
1 4 1
2 2 2
1 1 2
1 2 4
2 2 1
输出样例1：
13 13 5 3

暴力做法： 观察题意有两个操作：1.将两个点合并。2.将a点所在的集合全部点都加上t。
首先先说下暴力做法，连接用普通并查集维护，然后对于每次要加上权值时，遍历集合每个点即可。时间复杂度是O(nm),显然是会超时的，但是得到的分数非常可观，能拿70%的分数。

#include<bits/stdc++.h>
using namespace std;
const int N = 10010;
int w[N],p[N];
int Find(int x)
{
    if(x != p[x]) p[x] = Find(p[x]);
    return p[x];
}
void Union(int a,int b)
{
	int x = Find(a);
    int y = Find(b);
    if(x != y) p[x] = y;
}
int main()
{
    int n,m;
    cin >> n >> m;
    for (int i = 1; i <= n ; i ++ ) p[i] = i;
    for (int i = 0; i < m ; i ++ )
    {
        int a,b,c;
        cin >> a >> b >> c;
        if(a == 1)
        {
            Union(b,c);
        }
        else
        {
            int x = Find(b);
            for (int i = 1; i <= n; i ++ )
            {
                if(x == Find(i)) w[i] += c;
            }
        }
    }
    for (int i = 1; i <= n; i ++ ) cout<<w[i]<<" ";
    return 0;
}

满分答案： 直接看门见山，本题正解是用带权并查集做，根据题意的两个操作来看：1.将两个点合并。2.将a点所在的集合全部点都加上t。如果我们要优化时间的话，能下手的就只有第二个操作了。

那首先我们定义，每个结点的权值就是到根节点权值和。那我们第二个操作可以看成是，每次在a点所在集合的根节点加上t。那我们这样定义可以保证每个点权值都正确吗？答案是可以的，我们并查集存在路径压缩的操作，所以权值和是可以通过路径压缩来维护。那这样我们每次添加的时候，就只需要让根结点添加即可，时间复杂度就从O(nm) 降到了O(n).

还没完，我们现在需要根据上边的新定义，来保证我们的压缩路径和结点合并的合法性。

先看结点合并，当我们两个结点合并的时候是意味着我们两个树会进行合并，比如下面这个例子，如果权值为5的根结点要合并到权值为4的根节点上，那根据我们上边的定义，那权值为5的根结点将会全部加上4，那这显然就不对了。那要解决这个问题的话，我们可以让5的权值减去4，这样就能保证合法。合并起来的话，权值依旧不变。

接下来就是处理路径压缩了，那对于我们的x结点有三种情况，第一种x就是根结点，这种情况我们就直接返回即可，第二种就是x的父节点就是根节点，那这种情况我们也是直接退出（并查集最多压缩成两层，不清楚的话就需要去复习下基础并查集了）。最后一种就是我们要处理的，x经过若干层才到根结点。那我们压缩路径要做的就是让x直接指向根节点，在这种情况下，那随着我们压缩路径，x最终变成第三层，那我们此时的x权值就要更新成，d[x] += d[p[x]](加上x父亲指向上边结点的权值）。

那到此为止，细节处理完毕，直接coding解决。最终时间复杂度O(nlogn) 并查集的压缩路径时间为logn，但是一般实际运行速度可以看成O(1)

#include<bits/stdc++.h>
using namespace std;
const int N = 10010;
int p[N],d[N];
int Find(int x)
{
    if(p[x] == x || p[p[x]] == p[x]) return p[x];
    int r = Find(p[x]);
    d[x] += d[p[x]];
    p[x] = r;
    return r;
}
int main()
{
    int n,m;
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ ) p[i] = i;
    while(m -- )
    {
        int a,b,t;
        cin >> t >> a >> b;
        if(t == 1)
        {
            a = Find(a),b = Find(b);
            if(a != b)
            {
                d[a] -= d[b];                    //合并时，a结点的权值要减去b结点的权值
                p[a] = b;
            }
        }
        else
        {
            a = Find(a);
            d[a] += b;                           //直接往根结点上加权
        }
    }
    for (int i = 1; i <= n; i ++ ){
        if(Find(i) == i) printf("%d ",d[i]);       //如果是根结点，权值就为自己
        else printf("%d ",d[i] + d[Find(i)]);      //如果不是根结点，权值需要加上根节点的值
    }
    return 0;
}

结语

带权并查集算是很复杂的数据结构了，如果不懂的话，比赛的时候就直接暴力吧。