穿越雷区---BFS基础题解

蓝桥杯—穿越雷区（BFS）

题面链接：穿越雷区

Breadth First Search or BFS for a Graph

广度优先搜索算法被运用于在图形数据结构中搜索满足一组条件得节点。它从图形的根节点开始，访问当前深度级别的所有节点，然后再移动到下一个深度级别的节点。

使用邻接列表实现BFS for Graph:

// C++ code to print BFS traversal from a given
// source vertex

#include <bits/stdc++.h>
using namespace std;

// 用一个类表示有向图
class Graph {
//邻接表得表示
	int V;//代表顶点数
	// 指向包含邻接表得指针
	vector<list<int> > adj;
	
public:
	//在此构造函数
	Graph(int V);

	// 在图上添加边数
	void addEdge(int v, int w);

	// 打印BFS遍历
	void BFS(int s);
};

Graph::Graph(int V)
{
	this->V = V;
	adj.resize(V);
}

void Graph::addEdge(int v, int w)
{
	// 把w添加到v得列表里
	adj[v].push_back(w);
}

void Graph::BFS(int s)
{
	// 初始化所有顶点为未访问
	vector<bool> visited;
	visited.resize(V, false);

	// 创建BFS队列
	list<int> queue;

	// 将当前节点标记为已访问并入队
	visited[s] = true;
	queue.push_back(s);

	while (!queue.empty()) {

		// 将队列出列并打印
		s = queue.front();
		cout << s << " ";
		queue.pop_front();

		// 获取出队节点的所有邻接节点
		// s顶点
		// 如果相邻节点没有被访问过，标记为已访问并入队
		for (auto adjacent : adj[s]) {
			if (!visited[adjacent]) {
				visited[adjacent] = true;
				queue.push_back(adjacent);
			}
		}
	}
}

int main(void)
{
	// 创建图中的图形
	Graph g(4);
	g.addEdge(0, 1);
	g.addEdge(0, 2);
	g.addEdge(1, 2);
	g.addEdge(2, 0);
	g.addEdge(2, 3);
	g.addEdge(3, 3);

	cout << "广度优先搜索遍历结果 "
		<< "(从顶点2开始) \n";
	g.BFS(2);

	return 0;
}

抽象BFS基础解题模板

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

const int MAXN = 100; // 根据题目需要调整最大节点数

vector<int> adj[MAXN]; // 邻接表表示图
bool visited[MAXN];    // 记录节点是否被访问过

void bfs(int start) {
    queue<int> q;
    q.push(start);
    visited[start] = true;

    while (!q.empty()) {
        int current = q.front();
        q.pop();

        // 处理当前节点（根据题目需求）
       	//一般是向四周做当前级别节点的遍历
        //此题就是如此

        // 遍历当前节点的邻居
        for (int neighbor : adj[current]) {
            if (!visited[neighbor]) {
                q.push(neighbor);
                visited[neighbor] = true;
            }
        }
    }
}

int main() {
    // 读入图的信息，建立邻接表

    int n, m; // 节点数和边数
    cin >> n >> m;

    // 初始化邻接表
    for (int i = 0; i < m; ++i) {
        int u, v; // 边的两个节点
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u); // 无向图需要加上这一行
    }

    // 初始化visited数组
    fill(visited, visited + n, false);

    // 从某个节点开始进行BFS
    bfs(0); // 例如从节点0开始

    return 0;
}

分析题意

从地图A点出发每次选择与上一次不同的路径，以最短的路径到达B点。

实现思路

这道题目是BFS典型模板题，首先使用pair<template T1，template T2>类型模板存储队列节点坐标，接着创建地图。BFS实现创建队列，初始化长度数组，遍历从A点开始先找到A点所在位置，并初始化距离dist为0，将A顶点入队，遍历四周，确定坐标范围和选择正确的路径，队列到达B点BFS函数执行结束返回长度，否则将该级别的节点再次入队，没找到正确路径，否则返回-1。

题解

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> PII;
#define x first
#define y second
const int N = 100;
int dir[4][2] = {{1,0},{0,1},{-1,0},{0,-1}};//遍历方向 
int dist[N][N];//距离计算 
int n;
vector<vector<char>> mp(N, vector<char>(N)); //创建二维图形 

int bfs() {
    queue<PII> q; // 初始化队列 
	memset(dist,-1,sizeof dist);
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
            if (mp[i][j] == 'A') {
                dist[i][j] = 0;
                q.push({i, j});
            }

    while (!q.empty()) {
        auto t = q.front();
        q.pop();

		//更新节点坐标
        for (const auto& d : dir) {
            int dx = t.x + d[0];
            int dy = t.y + d[1];
			//确定寻找路径正确
            if (dx < 0 || dy < 0 || dx >= n || dy >= n || mp[dx][dy] == mp[t.x][t.y] || dist[dx][dy] != -1)
                continue;

            dist[dx][dy] = dist[t.x][t.y] + 1; 

            if (mp[dx][dy] == 'B')
                return dist[dx][dy];

            q.push({dx, dy});
        }
    }

    return -1;
}

int main() {
    cin >> n;

    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
            cin >> mp[i][j];

    cout << bfs() << endl;
    return 0;
}

小结

BFS是一种图遍历算法，主要运用于最短路径问题找到两个节点之间的最短路径（在迷宫中找到从起点到终点的最短路径。）连通性问题可以用于确定图或网络中节点之间的连通性，或者在迷宫中查找所有可达的区域。

与DFS不同的是BFS按层级遍历，从起始节点开始，先访问离起点最近的节点，然后是下一层级的节点。DFS则沿着一个分支尽可能深入，直到无法再深入为止，然后回溯到上一层，继续下一个分支。BFS通常使用Queue作为辅助发数据结构，而DFS通常使用栈（一般是显式的调用栈或递归调用栈）。