leetcode刷题 547. 省份数量 Medium Java DFS+BFS+并查集

这题可以和# 200. 岛屿数量一起写。

1.题目描述

有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。

省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。

给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。

返回矩阵中 省份 的数量。

示例 1：

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

输出：2

示例 2：

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

输出：3

提示：

• 1 <= n <= 200
• n == isConnected.length
• n == isConnected[i].length
• isConnected[i][j] 为 1 或 0
• isConnected[i][i] == 1
• isConnected[i][j] == isConnected[j][i]

来源：力扣（LeetCode）

链接：547. 省份数量

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.题解

这道题先把节点看成城市，而城市（city）之间如果可达，那么这些城市变成一个省份(province)。而省份也就是图中的连通分量。我们要求的也就是连通分量的个数。

连通分量:无向图中的极大连通子图称为连通分量。 求图的连通分量的目的，是为了确定从图中的一个顶点是否能到达图中的另一个顶点，也就是说，图中任意两个顶点之间是否有路径可达。

2.1 深度优先搜索（DFS）

2.1.1 思路

深度优先搜索是实现有栈和递归两种方式，而递归较为容易实现。
我们这道题因为是要找到城市的周边，而在矩阵中第i行和第i列都表示这个城市，因此矩阵是对称的，我们只需要遍历行或者列就行。
假如我们先从第0行开始遍历，为了防止重复遍历，我们需要一个visited[]来判断是否已经遍历过了。同时我们还需要一个值用来记录province的数量。

• 首先找到第一个未被遍历的城市，然后进入dfs。
• dfs中的 j 如果未被遍历同时isConnected值为1，说明和第 i 个城市连通。标记为visited
• 那与第 j 个城市连通，自然也与第 i 个城市也连通，所以继续向下遍历。
• 而所有递归完成后与第 i 个城市连通的所有城市都为visited，再查找到的就是新的省份了。

2.1.2 Java代码

class Solution {
    public int findCircleNum(int[][] isConnected) {
        if(isConnected == null || isConnected.length == 0){
            return 0;
        }
        int cities = isConnected.length;
        boolean []visited = new boolean[cities];
        int provinces = 0;
        for(int i=0;i<cities;i++){
            if(visited[i] == false){
                dfs(isConnected,visited,cities,i);
                provinces++;
            }
        }
        return provinces;
    }
    public void dfs(int[][] isConnected,boolean[]visited,int cities,int i){
        for(int j=0;j<cities;j++){
            if(visited[j] == false&&isConnected[i][j]==1){
                visited[j] = true;
                dfs(isConnected,visited,cities,j);
            }
        }
    }
}

2.2 广度优先搜索（BFS）

2.2.1 思路

BFS就相当于把DFS中的递归改成了使用队列的while循环，所有想要用dfs()处理的都add（）进queue。

• 首先需要找到未被访问过的city,add进queue.
• 然后通过while，找到所有与该city连通的cities,找到一个visited一个，然后add（）进queue。
• 一次while表示一次连通分量的查找完成，所以province++,也可以在前面++
• 最后所有的额未被访问过的点都访问过之后就可以return了。

2.2.2 Java代码

class Solution {
    public int findCircleNum(int[][] isConnected) {
        if(isConnected == null || isConnected.length == 0){
            return 0;
        }
        int cities = isConnected.length;
        boolean []visited = new boolean[cities];
        int provinces = 0;
        Queue<Integer> queue = new LinkedList<Integer>();
        for(int i =0 ;i<cities;i++){
            if(visited[i] == false){
                queue.add(i);
                visited[i] = true;
                while(!queue.isEmpty()){
                    int x = queue.remove();
                    for(int j = 0;j<cities;j++){
                        if(visited[j] == false&&isConnected[x][j] == 1){
                            queue.add(j);
                            visited[j] = true;
                        }
                    }
                }
                provinces++;
            }
        }
        return provinces;
    }
}

2.3 并查集

2.3.1 思路

这道题使用并查集，province就是并查集最后集合的个数,也就是parent的个数。
并查集最重要的是union和find。

• union也就是合并，就是将x的parent指向y的parent就行。
• find也就是查找，使用递归一直找到parent点。也可以用while实现。

题目要求的函数就是找到两个需要union的值，其中j = i+1,是因为是对称矩阵，这样可以节约时间。
之后遍历parent，parent的特点就是parent[i] = i，所有的parent就是province的个数。

2.3.2 Java代码

class Solution {
    public int findCircleNum(int[][] isConnected) {
        int cities = isConnected.length;
        int []parent = new int[cities];
        for(int i =0 ;i<cities;i++){
            parent[i] = i;
        }
        for(int i =0 ;i<cities;i++){
            for(int j = i+1 ; j<cities ;j++){
                if(isConnected[i][j] == 1){
                    union(parent,i,j);
                }
            }
        }
        int provinces = 0;
        for(int i = 0;i<cities;i++){
            if(parent[i] == i){
                provinces++;
            }
        }
        return provinces;
    }

    public void union(int []parent,int x,int y){
        parent[find(parent,x)] = find(parent,y);
    }

    public int find(int []parent,int i){
        if(parent[i]!=i){
            parent[i] = find(parent, parent[i]);
        }
        return parent[i];
    }
}