[leetcode] 并查集（Ⅱ）

Posted 2020-12-05 sinkinben

最长连续序列

题目[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]：??这题有点难。

解题思路

参考 题解1 和 题解2 。

首先，对原来的并查集结构添加一点改进，利用 vector<int> size[N] 记录某个连通分量中节点的数目，注意当且仅当 x 是该连通分量的根节点时，size[x] 才表示该连通分量的节点数目。这是因为在 merge 中，只对根节点的 size 进行了处理。

vector<int> root;
vector<int> size;
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, size[x] += size[y];	// pay attention here
}
// get the size of the connected component where node x is in
int getComponentSize(int x)
{
    return size[find(x)];
}

然后，建立一个基本图，该图是原图 graph 去除所有感染节点 initial 的结果，并把这个基本图转换为上述改进后的并查集。把这个基本图中的节点暂且称为 clean nodes 或者 non-infected nodes .

从直觉上来说，我们应该在 initial 中找到那个标号最小，感染最多 non-infected nodes 的节点，但是这样是否符合预期？

显然是不符合的，来看个例子，设 initial nodes = [a,b,c] ，并设 2 个没有被感染的连通分量为 N1, N2 ，且这 2 个连通分量的点数满足 size(N1) > size(N2)，原图 graph 结构如下：

a--N1--c

b--N2

根据题目的意思，需要找到的是使得最终感染数目 M(initial) 最小的节点。

如果我们按照上述所谓的「直觉」：“在 initial 中找到那个感染最多 non-infected nodes 的节点”，应该去除的是节点 a ，但是由于 c 的存在，N1 依旧会被感染，这样 M(initial) = size(N1) + size(N2)。（也就是说，某个连通分量相邻的感染节点多于 1 个，该连通分量最终是必然被感染的，因为我们只能去除一个感染节点。）

实际上，这种情况下正确答案是去除 b ，因为除 b 后：M(initial) = size(N1) ，该结果才是最小的。

所以，我们要找的是：在 initial 中找到那个感染最多 non-infected nodes 的节点 ans，但这些 non-infected nodes 节点只能被 ans 感染，不能被其他的 initial 节点感染（即只能被感染一次）。

代码实现

class Solution
{
public:
    vector<int> root;
    vector<int> size;
    int minMalwareSpread(vector<vector<int>> &graph, vector<int> &initial)
    {
        int N = graph.size();
        root.resize(N, -1);
        size.resize(N, 1);

        // use hash table to mark infected nodes
        vector<bool> init(N, false);
        for (int x : initial)
            init[x] = true;
        // change the non-infected graph into disjoint union set
        for (int i = 0; i < N; i++)
        {
            if (init[i])
                continue;
            for (int j = 0; j < i; j++)
            {
                if (init[j])
                    continue;
                if (graph[i][j] == 1)
                    merge(i, j);
            }
        }
        // table[x] = {...}
        // the set {...} means the non-infected components which initial node x will infect
        // counter[x] = k
        // k means that the non-infected component x will be infected by initial nodes for k times
        vector<int> counter(N, 0);
        unordered_map<int, unordered_set<int>> table;
        for (int u : initial)
        {
            unordered_set<int> infected;
            for (int v = 0; v < graph[u].size(); v++)
            {
                if (!init[v] && graph[u][v] == 1)
                    infected.insert(find(v));
            }
            table[u] = infected;
            for (int x : infected)
                counter[x]++;
        }

        // find the node we want
        int ans = N + 1, maxInfected = -1;
        for (int u : initial)
        {
            int sum = 0;
            for (int x : table[u])
                if (counter[x] == 1)	// must be infected only once
                    sum += getComponentSize(x);
            if (sum > maxInfected || (sum == maxInfected && u < ans))
            {
                ans = u;
                maxInfected = sum;
            }
        }
        return ans;
    }

    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, size[x] += size[y];
    }

    int getComponentSize(int x)
    {
        return size[find(x)];
    }
};

尽量减少恶意软件的传播

题目[924]：??做了上面那题之后简单一点。

解题思路

依然是使用上题中 尽量减少恶意软件的传播 II 改进后的并查集结构。

对整个原图处理，转换为并查集。然后，模拟处理。即 (forall x in initial) ，使用集合 (newSet = initial - {x}) 去模拟感染原图，得到最终的感染节点数 t，选取感染节点数 t 最小且标号值最小的 (x) 作为返回结果。

代码实现

class Solution
{
public:
    vector<int> root, size;
    int minMalwareSpread(vector<vector<int>> &graph, vector<int> &initial)
    {
        int N = graph.size();
        root.resize(N, -1);
        size.resize(N, 1);

        for (int i = 0; i < N; i++)
            for (int j = 0; j < i; j++)
                if (graph[i][j] == 1)
                    merge(i, j);

        int ans = N + 1, minval = N + 1;
        // assume that discard the node x in the initial set
        // get the injected value
        for (int x : initial)
        {
            int t = getInjected(x, initial);
            if (t < minval || (t == minval && ans > x))
            {
                minval = t;
                ans = x;
            }
        }
        return ans;
    }
    // use set initial - {x} to inject the graph
    int getInjected(int x, vector<int> &initial)
    {
        unordered_set<int> s;
        for (int k : initial)
        {
            if (k == x)
                continue;
            s.insert(find(k));
        }
        int sum = 0;
        for (int t : s)
            sum += size[find(t)];
        return sum;
    }
    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, size[x] += size[y];
    }
};

被围绕的区域

题目[130]：??本题难度一般。

解题思路

本题最特殊的节点是边界上的 O 以及内部与边界 O 相邻的节点。

首先，通过边界的 O 入手，从它开始进行 DFS 搜索，把所有这些的特殊节点标记为 Y 。然后，在 board 中剩下的 O 就是普通的节点（必然是不与边界 O 相邻且被 X 所围绕的），可以把它们全部换成 X 。最后，把所有的 Y 还原为 O 。

对于搜索方法，既可以是 DFS 也可以是 BFS。

代码实现

class Solution
{
public:
    const vector<vector<int>> direction = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    int row, col;
    void solve(vector<vector<char>> &board)
    {
        row = board.size();
        if (row == 0)
            return;
        col = board[0].size();
        #define func bfs
        for (int j = 0; j < col; j++)
        {
            if (board[0][j] == ‘O‘)
                func(0, j, board);
            if (board[row - 1][j] == ‘O‘)
                func(row - 1, j, board);
        }

        for (int i = 0; i < row; i++)
        {
            if (board[i][0] == ‘O‘)
                func(i, 0, board);
            if (board[i][col - 1] == ‘O‘)
                func(i, col - 1, board);
        }

        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                if (board[i][j] == ‘O‘)
                    board[i][j] = ‘X‘;
                if (board[i][j] == ‘Y‘)
                    board[i][j] = ‘O‘;
            }
        }
    }

    void dfs(int i, int j, vector<vector<char>> &board)
    {
        board[i][j] = ‘Y‘;
        for (auto &v : direction)
        {
            int a = i + v[0], b = j + v[1];
            if (a < 0 || b < 0 || a >= row || b >= col)
                continue;
            if (board[a][b] == ‘O‘)
                dfs(a, b, board);
        }
    }

    void bfs(int i, int j, vector<vector<char>> &board)
    {
        typedef pair<int, int> node;
        queue<node> q;
        q.push(node(i, j));
        board[i][j] = ‘Y‘;
        while (!q.empty())
        {
            node n = q.front();
            q.pop();
            for (auto &v : direction)
            {
                int a = n.first + v[0], b = n.second + v[1];
                if (!(a < 0 || b < 0 || a >= row || b >= col) && board[a][b] == ‘O‘)
                    board[a][b] = ‘Y‘, q.push(node(a, b));
            }
        }
    }
};