bfs/dfs的应用--countComponents

题目

你是自己所在州交通部门的首席技术专家。有许多城市通过公路网络连通，即交通可以沿任一方向流动。一些“城市组”可能会与其他断开，形成集群。

一个集群是一组彼此间连通且与其他部分相断开的城市组。假设一条路最多可连接两个给定的城市。给定这样一个城市和公路网络，求内部连通城市集群总数。

类Count_Components的方法countComponents的输入包括一个二维网络，且在第i个城市到第j个城市连通时，输入条目为（i,j）为1，否则为0。

该方法应返回一个表示连通分支总数的整数。grid只包含0和1.

代码

import java.util.ArrayDeque;

//给定一个无向图的邻接矩阵，只有1和0，1表示关联
//统计其中的连通分量个数
public class Count_Components {

	public static int countComponents_dfs(int grid[][]) {
		int count = 0;
		if (grid == null || grid.length == 0 || grid[0].length == 0 || grid.length != grid[0].length) {
			return count;
		}

		int nodes = grid.length;

		boolean visited[] = new boolean[nodes];
		for (int i = 0; i < visited.length; i++) {
			if (visited[i] == false) {
				dfsComponent(grid, i, visited);
				count++;
			}
		}

		return count;
	}

	// ******************************************************************************
	private static void dfsComponent(int[][] grid, int i, boolean[] visited) {
		visited[i] = true;
		for (int j = 0; j < visited.length; j++) {
			if (grid[i][j] == 1 && visited[j] == false) {
				dfsComponent(grid, j, visited);
			}
		}

	}

	private static int countComponents_bfs(int[][] grid) {
		int count = 0;
		if (grid == null || grid.length == 0 || grid[0].length == 0 || grid.length != grid[0].length) {
			return count;
		}
		int nodes = grid.length;
		boolean visited[] = new boolean[nodes];
		ArrayDeque<Integer> nodeQueue = new ArrayDeque<>();
		int curNode = 0;

		for (int i = 0; i < visited.length; i++) {

			if (visited[i] == false) {
				nodeQueue.offer(i);
				visited[i] = true;
				while (!nodeQueue.isEmpty()) {
					curNode = nodeQueue.poll();
					for (int j = 0; j < visited.length; j++) {
						if (grid[curNode][j] == 1 && visited[j] == false) {
							visited[j] = true;
							nodeQueue.offer(j);
						}
					}
				}
				count++;
			}

		}
		return count;

	}

	public static void main(String[] args) {
		int grid1[][] = new int[4][4];

		System.out.println(grid1.length + "行" + grid1[0].length + "列");
		for (int i = 0; i < grid1.length; i++) {
			for (int j = 0; j < grid1[0].length; j++) {
				grid1[i][j] = 1;
			}
		}
		System.out.println(countComponents_dfs(grid1));
		System.out.println(countComponents_bfs(grid1));

		int grid2[][] = new int[4][4];
		System.out.println(grid2.length + "行" + grid2[0].length + "列");
		for (int i = 0; i < grid2.length; i++) {
			for (int j = 0; j < grid2[0].length; j++) {
				if (i == j) {
					grid2[i][j] = 1;
				}

			}
		}
		System.out.println(countComponents_dfs(grid2));
		System.out.println(countComponents_bfs(grid2));

		int grid3[][] = new int[5][5];
		System.out.println(grid3.length + "行" + grid3[0].length + "列");
		grid3[1][1] = 1;
		grid3[1][2] = grid3[2][1] = 1;
		grid3[2][2] = 1;
		grid3[2][3] = grid3[3][2] = 1;
		grid3[4][3] = grid3[3][4] = 1;
		System.out.println(countComponents_dfs(grid3));
		System.out.println(countComponents_bfs(grid3));
	}

}

输出

4行4列
1
1
4行4列
4
4
5行5列
2
2