LintCode 432: Find the Weak Connected Component in the Directed Graph (并查集经典题)

最新推荐文章于 2022-11-26 20:07:31 发布

原创最新推荐文章于 2022-11-26 20:07:31 发布 · 268 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文探讨了如何在有向图中寻找弱连通分量的方法，主要介绍了使用并查集算法进行高效求解的过程。通过具体实例说明了并查集在处理此类问题上的优势，并提供了详细的代码实现。

Find the Weak Connected Component in the Directed Graph

Find the number Weak Connected Component in the directed graph. Each node in the graph contains a label and a list of its neighbors. (a weak connected component of a directed graph is a maximum subgraph in which any two vertices are connected by direct edge path.)

Example
Example 1:

Input: {1,2,4#2,4#3,5#4#5#6,5}
Output: [[1,2,4],[3,5,6]]
Explanation:

  1----->2        3-->5
   \     |        ^
    \    |        |
     \   |        6
      \  v
       ->4

Example 2:

Input: {1,2#2,3#3,1}
Output: [[1,2,3]]
Clarification
graph model explaination:
https://www.lintcode.com/help/graph

Notice
Sort the elements of a component in ascending order.

解法1：Union-Find
这题最好用并查集做。用BFS/DFS也可以做，但因为是有向图，必须把有向链接转换成无向链接才行。为什么呢？
比如说Input: {1,2,4#2,4#3,5#4#5#6,5}
Output: [[1,2,4],[3,5,6]]
Explanation:

1----->2          3-->5
   \     |        ^
    \    |        |
     \   |        6
      \  v
       ->4

如果用BFS/DFS的话，到了3就找不到6了，所以没法知道3和6是一组。
注意：
1）merge()的写法要注意。特别是最后是father[fatherX]=fatherY。不能写成father[x]=fatherY，这样x是连到了fatherY，但是fatherX到fatherY的链接就断了。为了简单起见，可以将merge(int x, int y)写成这样的模板：

void merge (int x, int y) {
    int x = find(x);
    int y = find(y);
    if (x != y) father[x]=y;
}

当union完成后，以input={1,2,3,4#2,3#3#4}为例，其各个节点的father如下。
1’s father is 3
2’s father is 4
3’s father is 4
4’s father is 4
此时并不能看出它们都是同一个father，所以最后的for循环里面还是必须用find(x)来找到各个节点的最上层祖宗，不能直接用father[x]。
father在这里必须用map，不能直接用数组，因为label可能很大(不一定是1,2,3,4,5)，另外也可能是负数。
代码如下：

/**

Definition for Directed graph.
struct DirectedGraphNode {
```
int label;
```
```
vector<DirectedGraphNode *> neighbors;
```

DirectedGraphNode(int x) : label(x) {};

};
*/

class Solution {
public:
/*
* @param nodes: a array of Directed graph node
* @return: a connected set of a directed graph
/
vector<vector> connectedSet2(vector<DirectedGraphNode> nodes) {
int n = nodes.size();

    //initialize, each node's father is itself
    for (auto node : nodes) {
        father[node->label] = node->label;
    }
    
    //union
    for (int i = 0; i < n; ++i) {
        for (auto neighbor : nodes[i]->neighbors) {
            merge(nodes[i]->label, neighbor->label);
        }
    }
    map<int, vector<int>> component; //father, children
    for (int i = 0; i < n; ++i) {
        int findFather = find(father[nodes[i]->label]);
        if (component.find(findFather) == component.end()) {
            component[findFather] = vector<int>();
        }
        
        component[findFather].push_back(nodes[i]->label); 
    }
    
    for (auto m : component) {
        result.push_back(m.second);
    }
    return result;
}

private:
map<int, int> father;
//vector father; //wrong, because label can be negative
vector<vector> result;

int find(int x) {
    if (x == father[x]) {
        return x;
    }
    father[x] = find(father[x]);
    return father[x];
}

void merge(int x, int y) {
    int fatherX = find(x);  //not fatherX = father[x];
    int fatherY = find(y);
    if (fatherX != fatherY) {
        father[fatherX] = fatherY;   //not father[y]
    }
}

};