BFS simple y fácil de entender

Primera búsqueda de amplitud, también conocida como primera búsqueda de amplitud, o bfs para abreviar. A diferencia de la búsqueda en profundidad, la búsqueda en amplitud primero buscará puntos que estén más cerca de la distancia de inicio y luego continuará buscando puntos que estén más lejos, mientras que la búsqueda profunda buscará a lo largo de una rama hasta el final.

BFS comienza desde el punto de inicio y primero busca el punto más cercano al punto de inicio, y luego expande otros puntos un poco más cerca de este punto más cercano, de modo que la expansión capa por capa es como la propagación de ondas de agua.

BFS debe implementarse con la ayuda de colas:

Al principio, ponga el punto de partida en la cola y marque el punto de partida para visitar
Si la cola no está vacía, tome un elemento x de la cola, de lo contrario el algoritmo finaliza
Visite todos los puntos v conectados ax, si v no ha sido visitado, ponga en cola v y márquelo como visitado
Repita el paso 2.

De acuerdo con esta idea, se puede derivar un marco de código simple:

void bfs(起始点) {
	将起始点放入队列中;
	标记起点访问;
	while (如果队列不为空) {
		访问队列中队首元素x;
		删除队首元素;
		for (x 所有相邻点) {
			if (该点未被访问过且合法) {
				将该点加入队列末尾;
			}
		}
	}
	队列为空，广搜结束;
}

Con respecto al problema del camino más corto del laberinto mencionado anteriormente, hemos aprendido a usar dfs para resolverlo. Usar dfs para resolver la ruta más corta del laberinto tiene una gran desventaja. Necesita enumerar todas las rutas posibles. Una vez que la lectura del mapa sea grande, el número de posibles esquemas de búsqueda será muy grande y la eficiencia de la búsqueda con dfs será obviamente ser muy bajo.

Podemos usar bfs para resolver el juego del laberinto. Dado que bfs es una búsqueda jerárquica, cuando se busca por primera vez el punto final, la cantidad de capas buscadas actualmente es la longitud de la ruta más corta.

Ejemplo 1: Título: Juego de laberinto Usamos una matriz de caracteres bidimensional para representar el laberinto dibujado anteriormente:

S**. 
....
***T

El carácter S representa el punto de partida, el carácter T representa el punto final, el carácter ∗ representa la pared y el carácter Representa el terreno plano. Debes comenzar de S a T. Solo puedes moverte hacia arriba, abajo, izquierda y derecha de ubicaciones adyacentes a la vez. No puedes salir del mapa o atravesar la pared. Solo puedes pasar por cada punto una vez. . Necesita programar para encontrar la ruta más corta desde el punto de inicio hasta el punto final

Dado que la solución BFS requiere una cola, establecemos la posición del punto como una estructura para facilitar el almacenamiento de la cola:

struct node {
	int x, y, d;
	node (int xx, int yy, int dd) {
		x = xx;
		y = yy;
		d = dd;
	}
};

Luego aplique el marco bfs mencionado anteriormente:

int bfs(int sx, int sy) {
	//将起始点放入队列中;
	queue<node> q;
	q.push(node(sx, sy, 0));
	//标记起点访问;
	vis[sx][sy] = true;
	while (!q.empty()){
		//访问队列中队首元素x;
		node now = q.front();
		//删除队首元素;
		q.pop();
		for (int i = 0; i < 4; ++i) {
			int tx = now.x + dir[i][0];
			int ty = now.y + dir[i][1];
			//该点未被访问过且合法
			if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty]) {
				if (maze[tx][ty] == 'T') {
					return now.d + 1;
				} else {
					//将该点加入队列末尾;
					vis[tx][ty] = true;
					q.push(node(tx, ty, now.d + 1));
				}
			}
		}
	}
	return -1;
}

Realización completa:

#include <iostream>
#include <string>
#include <queue>
using namespace std;
int n,m;
string maze[110];
bool vis[110][110];
int dir[4][2] = {
   
   {-1, 0}, {0, -1}, {1, 0}, {0, 1}};
bool in(int x, int y) {
	return 0 <= x && x < n && 0 <= y && y < m;
}
struct node {
	int x, y, d;
	node (int xx, int yy, int dd) {
		x = xx;
		y = yy;
		d = dd;
	}
};

int bfs(int sx, int sy) {
	queue<node> q;
	q.push(node(sx, sy, 0));
	vis[sx][sy] = true;
	while (!q.empty()){
		node now = q.front();
		q.pop();
		for (int i = 0; i < 4; ++i) {
			int tx = now.x + dir[i][0];
			int ty = now.y + dir[i][1];
			if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty]) {
				if (maze[tx][ty] == 'T') {
					return now.d + 1;
				} else {
					vis[tx][ty] = true;
					q.push(node(tx, ty, now.d + 1));
				}
			}
		}
	}
	return -1;
} 
int main() {
	cin >> n >> m;
	for (int i = 0; i < n; ++i) {
		cin >> maze[i];
	}
	int x, y;
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < m; ++j) {
			if (maze[i][j] == 'S') {
				x = i;
				y = j;
			}
		}
	}
	cout << bfs(x, y);
	return 0;
}

aporte:

5 6
…S*
.…
.….
*….
.T…

producción:

BFS simple y fácil de entender

Supongo que te gusta