[leetcode] 并查集（Ⅱ）

最长连续序列

题目[128]：链接。

解题思路

节点本身的值作为节点的标号，两节点相邻，即允许合并(x, y)的条件为x == y+1 。

因为数组中可能会出现值为 -1 的节点，因此不能把 root[x] == -1 作为根节点的特征，所以采取 root[x] == x 作为判断是否为根节点的条件。默认较小的节点作为连通分量的根。

此外，使用 map<int, int> counter 记录节点所在连通分量的节点个数（也是merge 的返回值）。

class Solution
{
public:
    unordered_map<int, int> counter;
    unordered_map<int, int> root;
    int longestConsecutive(vector<int> &nums)
    {
        int len = nums.size();
        // use map to discard the duplicate values
        for (int x : nums)
            root[x] = x, counter[x] = 1;
        int result = len == 0 ? 0 : 1;
        for (int x : nums)
        {
            if (root.count(x + 1) == 1)
                result = max(result, merge(x, x + 1));
        }
        return result;
    }
    int find(int x)
    {
        return root[x] == x ? x : (root[x] = find(root[x]));
    }
    int merge(int x, int y)
    {
        x = find(x);
        y = find(y);
        if (x != y)
        {
            root[y] = x;
            counter[x] += counter[y];
        }
        return counter[x];
    }
};

连通网络的操作次数

题目[1319]：Link.

解题思路

考虑使用并查集。

考虑到特殊情况，要使 N 个点连通，至少需要 N-1 条边，否则返回 -1 即可。

通过并查集，可以计算出多余的边的数目（多余的边是指使得图成环的边），只要 findroot(x) == findroot(y) 说明边 (x,y) 使得图成环。

遍历所有边，在并查集中执行合并 merge 操作（多余的边忽略不合并，只进行计数）。设 components 为合并后后 root 数组中 -1 的个数（也就是连通分量的个数），要想所有的连通分支都连起来，需要 components - 1 个边，所以要求「多余的边」的数目必须大于等于 components - 1。

一个简单的例子如下：

0--1         0--1                0--1
| /    =>    |          =>       |  |
2  3         2  3                2  3
             components = 2
             duplicateEdge = 1

代码实现

class Solution
{
public:
    vector<int> root;
    int result = 0;
    int makeConnected(int n, vector<vector<int>> &connections)
    {
        int E = connections.size();
        // corner cases
        if (n == 0 || n == 1)
            return 0;
        if (E < n - 1)
            return -1;
        root.resize(n), root.assign(n, -1);
        // merge
        for (auto &v : connections)
        {
            int a = v[0], b = v[1];
            merge(a, b);
        }
        int components = count(root.begin(), root.end(), -1);
        if (counter >= (components - 1))
            return components - 1;
        // should not be here
        return -1;
    }
    int find(int x)
    {
        return root[x] == -1 ? x : (root[x] = find(root[x]));
    }
    // the number of duplicate edges
    int counter = 0;
    void merge(int x, int y)
    {
        x = find(x), y = find(y);
        if (x != y)
            root[y] = x;
        else
        {
            // there is a duplicate edge
            counter++;
        }
    }
};

等式方程的可满足性

题目[990]：Link.

解题思路

考虑并查集。遍历所有的包含 == 的等式，显然，相等的 2 个变量就合并。对于不等式 x!=y ，必须满足 findroot(x) != findroot(y) 才不会出现逻辑上的错误。也就是说，不相等的 2 个变量必然在不同的连通分支当中。

#define getidx(x) ((x) - 'a')
class Solution
{
public:
    vector<int> root;
    bool equationsPossible(vector<string> &equations)
    {
        root.resize('z' - 'a' + 1, -1);
        vector<int> notequal;
        int len = equations.size();
        for (int i = 0; i < len; i++)
        {
            auto &s = equations[i];
            if (s[1] == '!')
            {
                notequal.emplace_back(i);
                continue;
            }
            int a = getidx(s[0]), b = getidx(s[3]);
            merge(a, b);
        }
        for (int i : notequal)
        {
            auto &s = equations[i];
            int a = getidx(s[0]), b = getidx(s[3]);
            if (find(a) == find(b))
                return false;
        }
        return true;
    }
    int find(int x)
    {
        return (root[x] == -1) ? x : (root[x] = find(root[x]));
    }
    void merge(int x, int y)
    {
        x = find(x), y = find(y);
        if (x != y)
            root[y] = x;
    }
};

尽量减少恶意软件的传播 II

题目[928]：