使用DFS和BFS统计省份数量

深度优先

广度优先

我们用一个二维数组来存储城市与城市之间的关系，若从城市i到城市j直接相连或间接相连，那么二维数组的[i][j]和[j][i]均为1，若无论如何也无法从一座城市抵达另外一座城市，则对应二维数组中两个值为0.约定城市到自己之间是连接的。

先来看看DFS.首先我们需要遍历一个存储了城市之间连通信息的二维数组，然后我们还需要一个数组来打标记，若某一座城市在遍历中已经被访问，那么以后遍历时，我们就不需要再访问了。由于二维数组长度就是城市数量，因此标记数组只需要开这么大。遍历时，我们就用两个for循环嵌套（这里涉及函数的调用，但本质上就是两个for循环嵌套），if判断时，我们不仅需要判断二维数组中两座城市之间是否相连，我们还需要判断在标记数组中是否被访问，判断后者可以减少时间复杂度。

private static void dfs(int i, int cities, boolean[] visited, int[][] citiesConnected) {
        for(int j = 0;j < cities;++j){
            if(citiesConnected[i][j] == 1 && !visited[j]){
                visited[j] = true;  //有关联，那么就打标记
                //然后递归，因为找到了所有跟i直接相连的城市，我们还需要找没有跟i直接相连的城市
                //也就是跟j直接相连的城市
                dfs(j, cities, visited, citiesConnected);  
            }
        }
    }

private static int getProvincesByDepth(int[][] citiesConnected) {
        int cities = citiesConnected.length;
        int provinces = 0;
        boolean[] visited = new boolean[cities];
        for(int i = 0;i < cities;++i){
            if(!visited[i]){   //因为在dfs方法里很多城市之间都打上了标记，因此这里其实会跳过很多城市
                dfs(i, cities, visited, citiesConnected);
                ++provinces;
            }
        }
        return provinces;
    }

再来看看广度优先：

我们就以某一座城市为中心，一圈一圈地挨个遍历，然后把这个圈子慢慢变大。所以这样一来一个while循环就足可以遍历完所有与这座城市相连的城市了。然后在外层for循环我们再找其他省份的城市。

private static void bfs(int i, int cities, boolean[] visited, int[][] citiesConnected) {
        Queue<Integer> queue = new LinkedList<Integer> ();
        queue.offer(i);
        while(!queue.isEmpty())  //这么一个循环，就可以实现以某一座城市为中心，呈辐射状向四周散开全部遍历
        {
            int temp = queue.poll();
            visited[temp] = true;
            for(int j = 0;j < cities;++j){
                if(citiesConnected[i][j] == 1 && !visited[j]) {
                    queue.offer(j);
                }
            }
        } //循环结束后再去找没有被标记的城市实行同样的操作
    }

private static int getProvincesByWidth(int[][] citiesConnected) {
        int cities = citiesConnected.length;
        int provinces = 0;
        boolean[] visited = new boolean[cities];
        for(int i = 0;i < cities;++i){
            if(!visited[i]){
                bfs(i, cities, visited, citiesConnected);
                ++provinces;
            }
            
        }
        return provinces;
    }

来看看运行效果：

 

 贴一波完整代码：

package com.hw.list0710;

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

public class GroupMerge {
    private static int getProvincesByDepth(int[][] citiesConnected) {
        int cities = citiesConnected.length;
        int provinces = 0;
        boolean[] visited = new boolean[cities];
        for(int i = 0;i < cities;++i){
            if(!visited[i]){   //因为在dfs方法里很多城市之间都打上了标记，因此这里其实会跳过很多城市
                dfs(i, cities, visited, citiesConnected);
                ++provinces;
            }
        }
        return provinces;
    }

    private static int getProvincesByWidth(int[][] citiesConnected) {
        int cities = citiesConnected.length;
        int provinces = 0;
        boolean[] visited = new boolean[cities];
        for(int i = 0;i < cities;++i){
            if(!visited[i]){
                bfs(i, cities, visited, citiesConnected);
                ++provinces;
            }
            
        }
        return provinces;
    }

    /**
     * 深度优先
     * @param i
     * @param cities
     * @param visited
     * @param citiesConnected
     */
    private static void dfs(int i, int cities, boolean[] visited, int[][] citiesConnected) {
        for(int j = 0;j < cities;++j){
            if(citiesConnected[i][j] == 1 && !visited[j]){
                visited[j] = true;  //有关联，那么就打标记
                //然后递归，因为找到了所有跟i直接相连的城市，我们还需要找没有跟i直接相连的城市
                //也就是跟j直接相连的城市
                dfs(j, cities, visited, citiesConnected);  
            }
        }
    }

    /**
     * 广度优先
     * @param i
     * @param cities
     * @param visited
     * @param citiesConnected
     */
    private static void bfs(int i, int cities, boolean[] visited, int[][] citiesConnected) {
        Queue<Integer> queue = new LinkedList<Integer> ();
        queue.offer(i);
        while(!queue.isEmpty())  //这么一个循环，就可以实现以某一座城市为中心，呈辐射状向四周散开全部遍历
        {
            int temp = queue.poll();
            visited[temp] = true;
            for(int j = 0;j < cities;++j){
                if(citiesConnected[i][j] == 1 && !visited[j]) {
                    queue.offer(j);
                }
            }
        } //循环结束后再去找没有被标记的城市实行同样的操作
    }

    public static void main(String[] args) {
        int[][] city = null;
        Scanner s = new Scanner(System.in);
        System.out.println("长度:");
        int length = s.nextInt();
        city = new int[length][length];
        System.out.println("输入数据:");
        for(int i = 0;i < length;++i) {
            for(int j = 0;j < length;++j) {
                city[i][j] = s.nextInt();
            }
        }
        s.close();
        int res1 = getProvincesByDepth(city);
        System.out.println("使用深度优先:共有"+res1+"个省份");
        int res2 = getProvincesByWidth(city);
        System.out.println("使用广度优先:共有"+res2+"个省份");
    }
}