省份数量-图的遍历

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

省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。 给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相 连，而 isConnected[i][j] = 0 表示二者不直接相连。 返回矩阵中 省份 的数量。

扩展：

亲戚问题、朋友圈问题

解法一：深度优先

获取一个城市，通过递归找到离该城市最远的城市，标记为已访问，然后逐个向内进行标记

上代码：

//22.省份数量
public class GroupMerge22 {
    public static void main(String[] args) {
        System.out.println(getProvince(new int[][]{{1,1,0},{1,1,0},{0,0,1}}));
        System.out.println(getProvince(new int[][]{{1,0,0},{0,1,0},{0,0,1}}));
    }

    private static int getProvince(int[][] citysConnected) {
        int citys = citysConnected.length;
        boolean[] visited = new boolean[citys];
        int provinces=0;
        for (int i=0;i<citys;i++){
            if (!visited[i]){
                //深度优先
                dfs(i,citys,visited,citysConnected);
                provinces++;
            }
        }
        return provinces;
    }

    private static void dfs(int i, int citys, boolean[] visited, int[][] citysConnected) {
        for (int j=0;j<citys;j++){
            if (citysConnected[i][j]==1 &&!visited[j]){
                visited[j]=true;
                dfs(j,citys,visited,citysConnected);
            }
        }
    }
}

结果：

2

3

解法二：广度优先

获取一个城市，先标记与该城市直连的城市(最近的)，然后逐步向外扩散寻找

上代码：

import java.util.LinkedList;
import java.util.Queue;

//22.省份数量
public class GroupMerge22 {
    public static void main(String[] args) {   
        System.out.println(bfs(new int[][]{{1,1,0},{1,1,0},{0,0,1}}));
        System.out.println(bfs(new int[][]{{1,0,0},{0,1,0},{0,0,1}}));
    }

    //广度优先
    public static int bfs(int[][] isConnected) {
        int citys = isConnected.length;
        boolean[] visited = new boolean[citys];
        int provinces = 0;
        Queue<Integer> queue = new LinkedList<Integer>();
        for (int i = 0; i < citys; i++) {
            if (!visited[i]) {
                queue.offer(i);
                while (!queue.isEmpty()) {
                    int k = queue.poll();
                    visited[k] = true;
                    for (int j = 0; j < citys; j++) {
                        if (isConnected[k][j] == 1 && !visited[j]) {
                            queue.offer(j);
                        }
                    }
                }
                provinces++;
            }
        }
        return provinces;
    }

}

结果：

2

3

解法三：并查集

将每个城市看成一个节点，如果两个城市相连，则建立树关系，选出其中一个为head， 如果两个树中的节点也相连，则将其中一个head设置为另一个树的head

两个方法 ：一个寻找head节点，一个合并树

import java.util.LinkedList;
import java.util.Queue;

//22.省份数量
public class GroupMerge22 {
    public static void main(String[] args) {
        System.out.println(mergeFind(new int[][]{{1,1,0},{1,1,0},{0,0,1}}));
        System.out.println(mergeFind(new int[][]{{1,0,0},{0,1,0},{0,0,1}}));
    }
    //并查集
    private static int mergeFind(int[][] citysConnected) {
        int citys = citysConnected.length;
        int[] head = new int[citys];
        int[] level = new int[citys];
        for (int i=0;i<citys;i++){
            head[i] = i;
            level[i] = 1;
        }
        for (int i=0;i<citys;i++){
            for (int j=i+1;j<citys;j++){
                if (citysConnected[i][j]==1){
                    merge(i,j,head,level);
                }
            }
        }
        int count=0;
        for (int i=0;i< citys;i++){
            if (head[i]==i){
                count++;
            }
        }
        return count;
    }
    private static void merge(int x,int y,int[] head,int[] level){
        int i = find(x,head);
        int j = find(y,head);
        if (i==j){
            return;
        }if (level[i]<=level[j]){
            head[i] = j;
        }else {
            head[j]=i;
        }
        if (level[i]==level[j]){
            level[i]++;
            level[j]++;
        }
    }

    private static int find(int x, int[] head) {
        if (head[x]==x){
            return x;
        }
        head[x] = find(head[x],head);
        return head[x];
    }
}

结果：

2

3