BFS学习笔记

BFS解决岛屿数量问题

题目

给定一个由 1（陆地）和 0（水）组成的矩阵，你需要计算岛屿的数量。岛屿由水平方向或垂直方向上相邻的陆地连接而成，并且四周都是水域。你可以假设矩阵外均被水包围。

输入描述：

第一行包含两个整数 N, M，表示矩阵的行数和列数。

后续 N 行，每行包含 M 个数字，数字为 1 或者 0。

输出描述：

输出一个整数，表示岛屿的数量。如果不存在岛屿，则输出 0。

输入示例：

4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1

思路

首先bfs使用队列进行处理，所以要熟练掌握Java的队列api，其次bfs是一层一层的向外搜索，这个可能不太清楚，我的理解是首先选择一个起始节点，先标记已访问，然后将起始节点放入队列；循环遍历队列，当队列不为空时，重复以下步骤：

1. 从队列中取出一个节点；
2. 访问该节点；
3. 将所有未访问的相邻节点标记为已访问，并将它们加入队列。

当队列为空时，算法结束。通过这种方式，BFS会先访问起始节点的所有直接邻居（第一层），然后访问这些邻居的未访问过的邻居（第二层），以此类推，直到所有可达的节点都被访问过。因此，可以认为BFS是按照“层”或“圈子”来遍历节点的，每一层都包含了到起始节点距离相等的所有节点。

JAVA

代码如下：

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

public class daoyushuliang_bfs {
	static int [][]dir = {{1,0},{-1,0},{0,1},{0,-1}};	
	
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		boolean[][]visited = new boolean[n][m];
		int [][]grid =new int[n][m];
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < m; j++) {
				grid[i][j] = sc.nextInt();
			}
		}
		int result = 0;
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < m; j++) {
				if(!visited[i][j]&&grid[i][j] == 1) {
					result++;
					bfs(grid,visited,i,j);
				}
			}
		}
		System.out.println(result);
	}
	
	public static void bfs(int [][]grid, boolean[][] visited, int x, int y) {
		Queue<int[]> queue = new LinkedList<>();
		queue.offer(new int[]{x,y});//把节点加入队列
		visited[x][y] = true;//立即处理节点
		while(!queue.isEmpty()) {
			//遍历节点
			int[] cur = queue.poll();//把当前头元素拿出
			int curx = cur[0];//存储当前点的x坐标
			int cury = cur[1];//存储当前点的y坐标
			for(int i = 0; i < 4; i++) {
				int nextx = curx+dir[i][0];
				int nexty = cury+dir[i][1];
			
			
			if(nextx < 0||nextx >= grid.length || nexty < 0 || nexty >= grid[0].length) {
				continue;
			}
			if(!visited[nextx][nexty] && grid[nextx][nexty] == 1) {
				queue.offer(new int[] {nextx,nexty});//将下一个点加入队列
				visited[nextx][nexty] = true;
			}
		}
			
			
			
		}
	}


}

总结

bfs(s) {
  q = new queue()
  q.push(s), visited[s] = true
  while (!q.empty()) {
    u = q.pop()
    for each edge(u, v) {
      if (!visited[v]) {
        q.push(v)
        visited[v] = true
      }
    }
  }
}

具体来说，我们用一个队列 Q 来记录要处理的节点，然后开一个布尔数组 vis[] 来标记是否已经访问过某个节点。

开始的时候，我们将所有节点的 vis 值设为 0，表示没有访问过；然后把起点 s 放入队列 Q 中并将 vis[s] 设为 1。

之后，我们每次从队列 Q 中取出队首的节点 u，然后把与 u 相邻的所有节点 v 标记为已访问过并放入队列 Q。

循环直至当队列 Q 为空，表示 BFS 结束。