【并查集】547. 省份数量

题目描述

(中等)有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。
省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。
给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。
返回矩阵中 省份 的数量。

示例：

输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]]
输出：2

解题思路

并查集，解图的连通性问题的利器！
什么是并查集，从数据结构上讲，它是物理上是线性表，即数组；它逻辑结构上又是森林(一组树)，也就是说用一个数组表示了整片森林。
并查集主要要求实现一下功能：

class UnionFindeed{
public:
	//parent数组，存储各结点的父节点
	int parent[];
	//将 p 和 q 连接 
    void union(int p, int q);
    //判断 p 和 q 是否连通
	boolean isConnected(int p, int q);
    //返回图中有多少个连通分量
    int count();
    //返回当前节点的根节点
    int find(int x);
}

如何表示一个连通分量各节点之间的连通性呢？

1. 利用parent[]数组，存储各结点的父节点(一个连通分量被视为一个树)；
2. parent[i]表示第i个结点的父结点；
3. 如果p和q连通，则其拥有相同的根节点；
4. 根节点有parent[i] = i，即自己指向自己。

并(Union)，怎么连接呢？只需要将一结点的根节点作为另一结点的根节点的父节点即可。之所以要找两个结点的根节点，是因为根节点的特性使其不存在父节点，在合并两个连通分量时不会产生父节点冲突的问题。

//伪码
void union(int p, int q){
	int root_p = find(p);
	int root_q = find(q);
	if(root_p != root_q){
		//随意！将一根节点置为另一根节点的父节点
		parent[root_p] = root_q;
	}
}

查(Find)，连接操作相当依赖查操作，实现起来也很简单，不断向上查找父节点，直到某一结点的父节点为其本身，该结点即为根节点。

int find(int node){
	while(parent[node] != node) node = parent[node];
	return node;
}

判断连接状态(isConnected)，只需判断两节点是否有相同的根节点。

bool isConnnected(int p, int q){
	return find(p) == find(q);
}

统计连通分量个数(count)，维护成员属性count，初始值为结点个数，有且仅有成功执行union()后count才可能减少。

int count;

void union(int p, int q){
	int root_p = find(p);
	int root_q = find(q);
	if(root_p != root_q){
		//成功合并，连通分量减 1 
		count--;
		parent[root_p] = root_q;
	}
}

int count(){
	return this->count;
}

优化并查集
实现上述功能的并查集尚存在可优化的空间，其中最影响算法性能的是find()，其余操作的时间复杂度可视为常数级，而find()的时间复杂度取决于树结构的深度。对于有 n 个结点 1 个连通分量的并查集来说，最坏的时间复杂度为 O(n)，最好的时间复杂度为 O(1)。

• 最坏情况：所有结点都没有兄弟结点；
• 最好情况：n个结点的 n - 1 叉树，即除了根结点，所有结点无子结点。

所以，可以明确我们的优化方向，即尽可能的时树扁平化，减小树的高度。
常见的优化方式有二：

1. 平衡性优化：当我们每次连接两个节点的时候，不希望出现头重脚轻的情况，而希望到达一种平衡的状态；
2. 路径压缩：使树的高度保持常数。

由于路径压缩比平衡性优化更常用，下面简单介绍路径压缩。

路径压缩
直接上代码：

int find(int node){
	while(node != parent[node]){
		//路径压缩
		parent[node] = find(parent[node]);
	}
	return parent[node];
}

递归实现，一次递归使递归结点的上的所有结点的parent[]的值为根节点。
路径压缩逻辑：

1. 递归到最深处，找到node == parent[node]的根结点；
2. 通过return 将根结点作为递归结果上抛；
3. 在每一层里，将当前结点的parent[]值修改为根结点。

代码实现

回到题目中来，初始化连通分量个数为城市数量，后遍历邻接矩阵isConnected将同一省份下的城市合并，连通分量个数相应减少。遍历完后返回最终连通分量个数，即省份数量。

class Solution {
    //连通分量计数
    int count;
    //parent[]数组头指针
    int* parent;
public:
	//并查集
    int findCircleNum(vector<vector<int>>& isConnected) {
        int n  = isConnected.size();
        //初始化为城市数量
        count = n;
        int a[n];
    	//parent[]初始化，初始状态设为所有结点都为根结点，即 parent[i] = i;
        parent = a;
        for(int i = 0; i < n; i++){
            parent[i] = i;
        }
        //由于邻接矩阵为对称矩阵，遍历时可以优化
        for(int i = 0; i < n; i++){
            for(int j = i + 1; j < n; j++){
                if(isConnected[i][j]){
                    Union(i, j);
                }
            }
        }
        return count;
    }
    //路径压缩后的查Find
    int find(int* parent, int key){
        if(parent[key] != key){
            parent[key] = find(parent, parent[key]);
        }
        return parent[key];
    }
	//与关键字union冲突，故方法名首字母大写。
    void Union(int a, int b){
        int root1 = find(parent, a);
        int root2 = find(parent, b);
        if(root1 != root2){
            parent[root1] = root2;
            count--;
        }
    }

};

运行结果：