java bfs题目与解析_Awesome算法解题框架——广度优先搜索（BFS）

Awesome算法解题框架系列：致力于探讨算法问题的框架思维，形成解题框架，用一个框架以点带面解决一类问题。问题千变万化，算法思维框架是不变的，以不变应万变。

广度优先搜索(以下简称BFS)是图的搜索算法中的一种基础算法，其核心思想是从源点出发一圈一圈向外扩展、逐层地毯式推进搜索。使用的核心数据结构是队列，此外为了存储路径，还需要一个哈希表。

下面是两个使用BFS算法的模板题，本文将从这两个问题出发，总结出BFS算法的通用解题框架模板，力求使用这套模板，可以快速解决BFS问题。

岛屿的最大面积

问题分析

图中上下左右连在一起的1的区域就是陆地，要找到这些陆地区域中最大的面积，朴素的思路就是：先找到所有的陆地区域，然后计算出最大的那个区域的面积。那么核心问题就转换为如何找到图中所有的陆地区域？当然是用BFS了。

和其他的BFS寻找最短路径问题稍有不同的是，本题并不需要寻找一个最短路径，因此不需要存储路径有关的信息。

代码实现

用Java实现：

// AC@7ms 12% 89%

class Solution {

public int maxAreaOfIsland(int[][] grid) {

// - 判空

if (null == grid || null == grid[0]) {

return 0;

}

// - 陆地是否处理过的标记数组

int row = grid.length;

int column = grid[0].length;

boolean[][] marked = new boolean[row][column];

// - 从左到右、从上到下第一个未被处理的陆地开始BFS处理

int maxLandArea = 0;

Queue queue = new LinkedList<>();

for(int i = 0; i < row; i++) {

for (int j = 0; j < column; j++) {

if (grid[i][j] == 1 && !marked[i][j]) {

// 当前陆地面积

int curArea = 0;

queue.add(new int[]{i, j});

while (!queue.isEmpty()) {

// 当前点

int[] cur = queue.poll();

curArea++;

// 标记当前点已处理

marked[cur[0]][cur[1]] = true;

// 获取当前点的上下左右未被处理的邻居陆地节点

List neighbors = unmarkedLandNeighbors(grid, cur, marked);

if (null != neighbors && neighbors.size() > 0) {

for (int[] nei: neighbors) {

queue.offer(nei);

// 标记当前邻居点已处理，否则会被重复添加

marked[nei[0]][nei[1]] = true;

}

}

}

// 更新最大面积

if (curArea > maxLandArea) {

maxLandArea = curArea;

}

}

}

}

return maxLandArea;

}

// 获取一个点上下左右的未被处理的邻居陆地节点的坐标列表，(行，列)下标二元组

private List unmarkedLandNeighbors(int[][] grid, int[] point, boolean[][] marked) {

int row = grid.length;

int column = grid[0].length;

int r = point[0];

int c = point[1];

List neighbors = new ArrayList<>();

// 上

if (r > 0 && grid[r-1][c] == 1 && !marked[r-1][c]) {

neighbors.add(new int[]{r-1, c});

}

// 下

if (r < row - 1 && grid[r+1][c] == 1 && !marked[r+1][c]) {

neighbors.add(new int[]{r+1, c});

}

// 左

if (c > 0 && grid[r][c - 1] == 1 && !marked[r][c-1]) {

neighbors.add(new int[]{r, c-1});

}

// 右

if (c < column - 1 && grid[r][c+1] == 1 && !marked[r][c+1]) {

neighbors.add(new int[]{r, c+1});

}

return neighbors;

}

}

迷宫问题

问题分析

这是一个典型的BFS算法问题，迷宫中有通路，也有障碍，从起点开始，运用BFS的逐层地毯式搜索，过程中记录每个搜索过的点的上一个节点的哈希表，直到遇到终点，最终就可以根据这个哈希表、从后往前"按图索骥"找到从起点到终点的最短路径。

代码实现

用Java实现：

// poj-3984 迷宫问题

import java.util.*;

class Main {

private static Main main = new Main();

public static void main(String[] argv) {

Scanner sc = new Scanner(System.in);

int[][] maze = new int[5][5];

for(int i = 0; i < 5; i++){

for(int j = 0; j < 5; j++){

maze[i][j] = sc.nextInt();

}

}

main.printShortestPath(maze);

}

// 打印从左上角到右下角的最短路径

private static void printShortestPath(int[][] maze) {

// - 判空

if (null == maze || null == maze[0] || maze.length == 0 || maze[0].length == 0) {

return;

}

// - 找到最短路径前驱map

Map, int[]> shortestPathPreMap = findShortestPathPreMap(maze);

// - 解析最短路径前驱map为最短路径列表

List path = parsePath(shortestPathPreMap, new int[]{4,4});

// - 打印最短路径

for (int[] p: path) {

System.out.println("(" + p[0] + ", " + p[1] + ")");

}

}

// 找到从左上角到右下角的最短路径，返回路径前驱节点map

private static Map, int[]> findShortestPathPreMap(int[][] maze) {

int row = maze.length;

int col = maze[0].length;

// - 标记某个点的前驱节点的哈希表

Map, int[]> preMap = new HashMap, int[]>();

// - 标记迷宫中的点有没有被搜索过的标记数组

boolean[][] searched = new boolean[row][col];

// - 待查找队列，存放待查找的点的(行，列)坐标，先把左上角的点入队

Queue searchQueue = new LinkedList();

searchQueue.offer(new int[]{0,0});

// - 遍历待查找队列

while (!searchQueue.isEmpty()) {

// - 出队当前点

int[] cur = searchQueue.poll();

// - 标记当前点为处理过

searched[cur[0]][cur[1]] = true;

// - 遍历当前点的邻居节点列表

List neighbors = getNeighbors(maze, cur, searched);

if (neighbors.size() > 0) {

for (int[] nei: neighbors) {

// 记录前驱节点

preMap.put(arr2List(nei), cur);

// 如果是终点，则返回前驱关系哈希表

if (nei[0] == row-1 && nei[1] == col-1) {

return preMap;

}

// 如果不是终点，入队，并标记为已经搜索过

searchQueue.offer(nei);

searched[nei[0]][nei[1]] = true;

}

}

}

return null;

}

// 获取cur点当前上下左右未被查找过且不是障碍物的邻居节点列表

private static List getNeighbors(int[][] maze, int[] cur, boolean[][] searched) {

List neighbors = new ArrayList();

int rowLen = maze.length;

int colLen = maze[0].length;

int row = cur[0];

int col = cur[1];

// 上

if (row > 0 && !searched[row-1][col] && maze[row-1][col] != 1) {

neighbors.add(new int[]{row-1, col});

}

// 下

if (row < rowLen - 1 && !searched[row+1][col] && maze[row+1][col] != 1) {

neighbors.add(new int[]{row+1, col});

}

// 左

if (col > 0 && !searched[row][col-1] && maze[row][col-1] != 1) {

neighbors.add(new int[]{row, col-1});

}

// 右

if (col < colLen - 1 && !searched[row][col+1] && maze[row][col+1] != 1) {

neighbors.add(new int[]{row, col+1});

}

return neighbors;

}

// 从preMap中解析出从起点到终点的路径列表

private static List parsePath(Map, int[]> preMap, int[] end) {

// 从起点到终点的路径列表

List path = new ArrayList();

// 当前节点：终点

int[] cur = end;

while (null != cur && !(cur[0] == 0 && cur[1] == 0)) {

path.add(cur);

cur = preMap.get(arr2List(cur));

}

// 加入起点

path.add(new int[]{0,0});

// 反转path

Collections.reverse(path);

return path;

}

// 把整型数组转为整型列表

private static List arr2List(int[] arr) {

List nums = new ArrayList();

for (int n: arr) {

nums.add(n);

}

return nums;

}

}

BFS算法框架总结

核心框架

把起点加入待搜索队列

while 待搜索队列不为空:

出队当前元素，并标记为已处理

获取当前元素的可达、合法、未被标记的邻居列表

for neighbor in [邻居列表]:

把neighbor加入待搜索队列

标记neighbor为已处理

核心框架伪代码

根据上面两个题目的代码，可以抽象出BFS算法解体框架的伪代码，伪代码中采用模块化的思想，封装了3个核心函数，每一个函数力求只做一件(简单的)事情：

// BFS算法主函数

BFS(matrix, start, end):

pre_map

path

return path

// 找到从起点到终点的最短路径的前驱关系哈希表

GET-SHORTEST-PATH-PRE-MAP(matrix, start, end):

// 待搜寻队列

search_queue

// 已搜寻过的点

searched_map

// 的关系表

pre_map

// 一开始将起点放入待搜寻队列

search_queue

while search_queue is not empty:

cur

// 标记当前点为已搜索过

searched_map[cur]

neighbors

for nei in neighbors:

// 记录前驱点关系

pre_map[nei]

// 判断是否找到终点

if nei is end:

return pre_map

search_queue

searched_map[nei]

// 找到一个点的可达、且未被标记过的邻居点列表

GET-NEIGHBORS(matrix, cur, searched_map):

neighbors

for point in up, down, left, right:

if point can access and searched_map[point] is false:

neighbors

return neighbors

// 把前驱关系哈希表解析为一个从起点到终点的路径列表

PARSE-PRE-MAP(pre_map, start, end):

path

cur

while cur is not start:

path

cur

path

path

return path

Java实现时的几点注意事项

使用Java实现上述框架的时候，需要注意如下几点事项：

Java中的队列可以使用LinkedList，其实现了Queue接口，其入队方法为offer，出队方法为poll，判断是否为空的方法为isEmpty。

为了方便，可以优先使用int[2]数组来表示一个点在矩阵中的(行, 列)坐标。

不能用数组作为Map的key，因为数组没有实现hashCode方法，而用整型List是可以作为Map的key的，有完全相同元素的两个List，其hachCode也是相同的。

寻找一个点的可达、未搜寻过的邻居节点的时候，可以按照上下左右的顺序进行查找，防止思路混乱。

总结

BFS算法的框架是非常明晰的，没有多少弯弯绕的东西，本文中用伪代码给出的解题框架适用于用二维矩阵表示的图，如果是以其他形式表示的图，那么代码只需稍作修改，也可以同样适用，框架思想是相通的。