CodeForce题解 —— Disjoint Sets Union 题集：C. Experience

题目相关

题目链接

CodeForce网站。https://codeforces.com/edu/course/2/lesson/7/1/practice/contest/289390/problem/C。

题面

In a novel online game, the players fight the monsters and get the experience, as usual. To fight monsters players join together in raid teams. After the destruction of the monster, all the players of the team get the same amount of experience points. The special feature of the game is that a team cannot be split up and no one can leave a team. The only supported operation is to join two teams together.

Since there are already a lot of people playing the game, you are asked to maintain the experience points of the players.

输入

The first line of the input contains two integers n and m () — the number of players and the number of queries.

Next m lines contain the description of queries, one per line. A query can be of three types:

• join X Y — join two teams to which players X and Y belong to (if they are already in the same team, nothing changes).
• add X V — add V (1 ≤ V ≤ 100) experience points to each player in a team to which player X belongs to.
• get X — output the current number of experience points of player X.

Initially, each player has 0 experience points and each of the player is in its own team of size one.

输出

For each query get X output the current number of experience points of player X on a separate line.

样例输入

3 6
add 1 100
join 1 3
add 1 50
get 1
get 2
get 3

样例输出

150
0
50

题解报告

题目分析

本题是一个 DSU（Disjoint Sets Union）的模板题，本题的难度在于如何记录成绩。最简单的思路就是在 DSU 模板中增加一个 vector 用来表示成绩，在每次 add 操作的时候，遍历关系，将所有同一个父节点的数据进行操作。类似代码如下：

    //加分
    void score(T x, T num) {
        _score[x]+=num;
        for (int i=0; i<_n; i++) {
            if (i!=x && relation(x, i)) {
                _score[i]+=num;
            }
        }
    }

这样做，可以达到程序的目的，但是考虑到数据为 ，每次 add 操作时间复杂度为 O(N)，这样的算法在大数据集肯定导致 TLE。因此，我们的问题变成如何将 O(N) 优化。

我们可以参考 DSU 的 find_root() 函数实现。

    //查找x的父亲
    T find_root(T u) {
        return (u== _p[u] ? u : find_root(_p[u]));
    }

使用递归的思路，将分数分为两个部分，也就是两个 vector，一个 vector 保存父节点为自己的分数，一个 vector 保存在 join 操作时候，对应的子节点分数。而 add 操作变更父节点的成绩。这样，我们可以模仿 find_root 通过递归来实现计算所有分数。完整代码如下。

    T score(T u) {
        return u==_p[u] ? _score[u]: (_score[u]-_extra[u]+score(_p[u]));
    }

当然也可以使用一个附加的数据保存节点关系，在 add 的时候，遍历节点关系。但是这个思路没有测试过。

样例数据分析

我们使用样例数据来解释一下这个分数保存过程。

初始状态

序号   _p   _score    _extra
0     0    0         0
1     1    0         0
2     2    0         0
3     3    0         0

如上述数据可知，现在有 3 个集合，分别为：{1}、{2}、{3}。

add 1 100

为 1 号加 100 分。这样我们对应的数据如下。

序号   _p   _score    _extra
0     0    0         0
1     1    100       0
2     2    0         0
3     3    0         0

join 1 3

将数据 1 和 3 合并，这样，我们的集合变成两个，分别为：{1 3} 和 {2}。由于是合并操作，所以我们要记录下对应数据如下：

序号   _p   _score    _extra
0     0    0         0
1     1    100       0
2     2    0         0
3     1    0         100

add 1 50

为 1 号加 100 分。这样我们对应的数据如下。

序号   _p   _score    _extra
0     0    0         0
1     1    150       0
2     2    0         0
3     1    0         100

get 1

由于 1 号是跟节点，因此直接输出 _score[1] 的数据 150。

get 2

由于 1 号是跟节点，因此直接输出 _score[2] 的数据 0。

get 3

由于 3 号是跟节点，需要递归计算。_score[3]-_extra[3]+score(_p[3])=0-100+score(1)=0-100+150=50。

AC代码

//https://codeforces.com/edu/course/2/lesson/7/1/practice/contest/289390/problem/C
//C. Experience

#include <bits/stdc++.h>

using namespace std;

//Disjoint Set Union
template <class T>
struct DSU {
private:
    /*
    当_p[x]<0的时候，说明x的父节点是自己。同时 |_p[x]| 表示集合内元素数量
    当_p[x]>0的时候，表示父节点
    */
    T _n;//数据容量
    std::vector<T> _p;//并查集关系
    std::vector<T> _size;//集合大小
    std::vector<T> _min;//最小值
    std::vector<T> _max;//最大值
    std::vector<T> _score;//分数
    std::vector<T> _extra;//以前分数

public:
    DSU(T n) : _n(n), _p(n, 0), _size(n, 1), _min(n, 0), _max(n, 0), _score(n, 0), _extra(n, 0) {
        iota(_p.begin(), _p.end(), 0);
        iota(_min.begin(), _min.end(), 0);
        iota(_max.begin(), _max.end(), 0);
    }
  
    //查找x的父亲
    T find_root(T u) {
        return (u== _p[u] ? u : find_root(_p[u]));
    }
 
    //建立关系
    bool union_set(T u, T v) {
        if (u<0 || u>=_n || v<0 || v>=_n) {
            return false;
        }
        u = find_root(u);
        v = find_root(v);
        if (u==v) {
            //两个已经在同一个集合
            return false;
        }
        if (_size[u]<_size[v]) {
            //保证不会出现单边增长
            swap(u, v);
        }
        _p[v] = u;
        _size[u] += _size[v];
        _min[u] = std::min(_min[u], _min[v]);
        _max[u] = std::max(_max[u], _max[v]);
        _extra[v] = _score[u];
        return true;
    }
 
    //查找u和v是否在同一个父亲
    bool relation(T u, T v) {
        if (u<0 || u>=_n || v<0 || v>=_n) {
            return false;
        }
        return find_root(u) == find_root(v);
    }

    //数据 u 所在集合大小
    T size(T u) {
        if (u<0 || u>=_n) {
            return 0;
        }
        return _size[find_root(u)];
    }

    //
    T min(T u) {
        if (u<0 || u>=_n) {
            return 0;
        }
        T t=find_root(u);
        return _min[t];
    }

    T mau(T u) {
        if (u<0 || u>=_n) {
            return 0;
        }
        T t=find_root(u);
        return _max[t];
    }

    //加分
    void score(T u, T num) {
        u=find_root(u);
        _score[u]+=num;
    }

    T score(T u) {
        return u==_p[u] ? _score[u]: (_score[u]-_extra[u]+score(_p[u]));
    }
}; //end of struct

int main() {
#if 1
    //提交到 CodeForces 需要使用快读，本地测试的时候，可以不使用。
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#endif

    int n,m;
    cin>>n>>m;

    DSU<int> dsu(n+1);
    for (int i=0; i<m; i++) {
        string op;
        int u,v;
        cin>>op;
        if ("join"==op) {
            cin>>u>>v;
            dsu.union_set(u, v);
        } else if ("add"==op) {
            cin>>u>>v;
            dsu.score(u, v);
        } else if ("get"==op) {
            cin>>u;
            int ans=dsu.score(u);
            cout<<ans<<"\n";
        }
    }

    return 0;
}