图的bfs_迷宫(迷宫问题)

BFS宽度优先搜索：应用最多的就是走迷宫问题

例如:给出一个5*5迷宫图
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

如上图的迷宫，入口，出口分别：左上角，右下角
"1"是墙壁，"0"是通路
求从左上角到右下角最短需要走多少步？

问题分析:

首先需要将每个点包装成一个节点 x,y,deep   

x:代表横座标          y:代表纵座标            deep:代表该点的深度(相当于是步数)

1、在走的过程中肯定不能走之前走过的(题目求的为最短),所以需要一个数组来标记该点是否被走过.

2、在走的过程中,需要判断能不能移动

   1、不能走出去          2、走的点必须是没有走过的点             3、这个点是否能走

3、在满足2的条件下,将该点加入到队列(queue)当中

4、判断是否已经走到了终点。如果已经到达了终点，结束程序

代码:

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

public class 图的bfs_迷宫 {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int m = 5;
    int n = 5;
    int[][] graph = new int[m][n];
    int[][] vis = new int[m][n];//标记哪些点已经被访问
    Queue<Node> queue = new LinkedList<>();
    for(int i = 0;i<m;i++)
    {
    	for(int j = 0;j<n;j++)
    	{
    		graph[i][j] = scanner.nextInt();
    	}
    }
    //初始化起点，深度为0
    Node start = new Node(0, 0, 0);
    queue.add(start);
    while (!queue.isEmpty()) {
      Node poll = queue.poll();
      int x = poll.x;
      int y = poll.y;
      int deep = poll.depth;
      vis[x][y] = 1;//标注为已访问
      //判断是否到达终点
      if (x == m - 1 && y == n - 1) {//走到出口
        System.out.println(poll.depth);
        break;
      }
      //  向左走，判断1、不能走出去，2.左边的位置没有被访问过，3.左边位置上的值要和现在的值相同
      //如果满足条件的话,就添加到队列当中
      if (x - 1 >= 0 && vis[x - 1][y] == 0 && graph[x - 1][y] == 0) {
        queue.add(new Node(x - 1, y, deep + 1));
      }
      //  向右走，判断1、不能走出去，2.左边的位置没有被访问过，3.左边位置上的值要和现在的值相同
      if (x + 1 < m && vis[x + 1][y] == 0 && graph[x + 1][y] == 0) {
        queue.add(new Node(x + 1, y, deep + 1));
      }
      //  向下走，判断1、不能走出去，2.左边的位置没有被访问过，3.左边位置上的值要和现在的值相同
      if (y - 1 >= 0 && vis[x][y - 1] == 0 && graph[x][y - 1] == 0) {
        queue.add(new Node(x, y - 1, deep + 1));
      }
      //  向上走，判断1、不能走出去，2.左边的位置没有被访问过，3.左边位置上的值要和现在的值相同
      if (y + 1 < n && vis[x][y + 1] == 0 && graph[x][y + 1] == 0) {
        queue.add(new Node(x, y + 1, deep + 1));
      }
    }

  }

  static class Node {
    int x;
    int y;
    int depth;//节点的深度相当于走的步数

    public Node(int x, int y, int depth) {
      this.x = x;
      this.y = y;
      this.depth = depth;
    }
  }
}

测试结果:

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
8