Primera búsqueda de amplitud (BFS)
Breadth-First Search (BFS) es también uno de los métodos de búsqueda. La búsqueda primero en amplitud busca primero el estado que está cerca del estado inicial. En otras palabras, se busca en el orden de estado inicial → todos los estados que se pueden alcanzar con una sola transición → todos los estados que se pueden alcanzar con solo dos transiciones → ……
La búsqueda en amplitud primero utiliza una cola para el cálculo. La cola admite operaciones de inserción y extracción, y los elementos de datos son los primeros en entrar, primero en salir. El archivo de encabezado es:#include <queue>
Ejemplo: el camino más corto del laberinto
Descripción del Título
Dado un laberinto de tamaño N × M. El laberinto se compone de pasajes y paredes, y cada paso puede moverse a los pasajes adyacentes de cuatro cuadrados. Solicite el número mínimo de pasos necesarios para llegar desde el punto de inicio hasta el punto final. Tenga en cuenta que esta pregunta asume que puede moverse desde el punto de partida al punto final.
Condiciones de restricción
N, M ≤ 100
Entrada de muestra
N = 10, M = 10 (El laberinto se muestra en la figura siguiente. '#', '.', 'S' y 'G' representan paredes, pasajes, puntos de inicio y final, respectivamente)
#S######.#
......#..#
.#.##.##.#
.#........
##.##.####
....#....#
.#######.#
....#.....
.####.###.
....#...G#
Salida de muestra
22
Análisis de temas
La búsqueda de amplitud primero busca en el orden de más cercano a más lejano del estado inicial, por lo que se puede utilizar fácilmente para encontrar respuestas a preguntas como la ruta más corta y la menor cantidad de operaciones. En este problema, el estado son solo las coordenadas de la ubicación actual, por lo que se puede construir pairo codificar intpara expresar el estado.
En la búsqueda de amplitud primero, siempre que el estado visitado se gestione con una marca, la búsqueda de cerca a lejos se puede realizar bien. En este problema, dado que se requiere la distancia más corta, también podríamos usar d[N][M]una matriz para guardar la distancia más corta. Inicialmente inicializarlo con una constante suficientemente grande INF, de modo que la posición que aún no se ha alcanzado sea INF, y también sirva como marcador.
Aunque la búsqueda se detendrá cuando llegue al punto final, si continúa hasta que la cola esté vacía, puede calcular la distancia más corta a cada ubicación. Además, si d sigue siendo INF al final de la búsqueda, se puede saber que no se puede llegar a esta posición desde el punto de partida.
Debido a que necesita moverse en 4 direcciones diferentes, use dos matrices dx[4]y dy[4]dos matrices para representar los cuatro vectores de dirección. De esta manera, se puede lograr un recorrido de movimiento en cuatro direcciones a través de un bucle.
Código
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int INF = 100000000;
const int MAX_N = 10001;
//使用pair表示状态时，使用typedef会更方便一些
typedef pair<int, int> P;
char maze[MAX_N][MAX_N+1]; //表示迷宫的字符串数组
int N, M;
int sx, sy; //起点坐标
int gx, gy; //终点坐标
int d[MAX_N][MAX_N]; //到各个位置的最短距离数组
//4个方向移动的向量
int dx[4] = {
1,0,-1,0}, dy[4] = {
0,1,0,-1};
//求从(sx,sy)到(gx,gy)的最短距离
//如果无法到达，则是INF
int bfs(){
queue<P> que;
//把所有的位置都初始化为INF
for(int i=0; i<N; i++)
for(int j=0; j<M; j++){
d[i][j] = INF;
}
//将起点加入到队列，并把这一地点的距离设置为0
que.push(P(sx,sy));
d[sx][sy] = 0;
//不断循环直到队列的长度为0
while(que.size()){
//从队列的最前端取出元素
P p = que.front();
que.pop();
//判断取出的元素是否为终点，若是终点，则结束搜索
if(p.first == gx && p.second == gy)
break;
//四个方向的循环
for(int i=0; i<4; i++){
//移动之后的位置记为(nx,ny)
int nx = p.first + dx[i], ny = p.second + dy[i];
//判断 是否可以移动以及是否已经访问过（d[nx][ny]!=INF即已经访问过）
if(0<=nx && nx < N && 0<=ny && ny < M && maze[nx][ny]!='#' && d[nx][ny]==INF){
//可以移动的话，则加入到队列，并且到该位置的距离确定为到p的距离+1
que.push(P(nx,ny));
d[nx][ny] = d[p.first][p.second] + 1;
}
}
}
return d[gx][gy];
}
int main(){
cin >> N >> M;
for(int i=0; i<N; i++)
for(int j=0; j<M; j++)
cin >> maze[i][j];
//确定起始位置坐标
for(int i=0; i<N; i++)
for(int j=0; j<M; j++){
if(maze[i][j] == 'S'){
sx = i;
sy = j;
}
else if(maze[i][j] == 'G'){
gx = i;
gy = j;
}
}
int res = bfs();
cout << res;
return 0;
}