（实时更新）蓝桥杯知识点笔记 | （四）宽搜

小标题的超链接为原题链接，点击跳转

2.2 广搜

定义&模板

宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。

所谓广度，即搜索路线为一层一层，由远及近的。

————————————————
版权声明：本文为CSDN博主「Jjwj11」的原创文章，遵循CC 4.0
BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Jjwj11/article/details/118873484

常用于：
(1)：求最短路径、最少操作
(2)：求联通块（与 DFS 类似）

// 模板
queue<int> q;
st[1] = true; // 表示1号点已经被遍历过
q.push(1);

while (q.size())
{
    int t = q.front();
    q.pop();

    for (int i = h[t]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true; // 表示点j已经被遍历过
            q.push(j);
        }
    }
}

大胖子走迷宫

题目

代码

// 大胖子走迷宫_bfs
#include <iostream>
#include <queue>
using namespace std;

const int N = 3e2 + 10;

struct node
{
	int x, y, step;
	node(){}
	node(int xx, int yy, int stepp)
	{
		x = xx, y = yy, step = stepp;
	}
};
queue<node> q;


int n, k;
bool st[N][N]; // 标记数组
// 方向数组
int dx[4] = {0,1,0,-1} ; 
int dy[4] = {1,0,-1,0} ;
// 地图
char map[N][N];

int f(int t) // 判断t时刻下的身材
{   
	if(t < k) return 2;
	if(t < 2*k) return 1;
	else return 0; 
}

bool boundary(int x, int y, int t) // 边界判断
{
	return (x+f(t) <= n && x-f(t) >= 1 && y+f(t) <= n && y-f(t) >= 1);	
}

bool run(int x, int y, int t) // 判断身材范围内是否有障碍#
{
	for(int i = x-f(t); i<=x+f(t); i++)
		for(int j = y-f(t); j<=y+f(t); j++)
			if(map[i][j] == '*') return false;
	return true;
}

bool check(node i)
{
	// 边界
	// 障碍
	// 标记
	return boundary(i.x, i.y, i.step) && !st[i.x][i.y] && run(i.x, i.y, i.step);
}

void bfs(node u)
{
	while(q.size())
	{
		node t = q.front();
		q.pop();
		if(t.x == n-2 && t.y == n-2)
		{
			cout << t.step;
			return;
		}

    if(t.step<2*k) q.push(node(t.x, t.y, t.step+1)); // 剪枝，正常人状态不需要原地停留

		for(int k=0; k<4; k++)
		{
			node nt(t.x + dx[k], t.y + dy[k], t.step); // 注意，第step+1步依然用step步的身材来判断
			if(check(nt))
			{
				st[nt.x][nt.y] = true;
				q.push(node(nt.x, nt.y, nt.step+1));// 在判断完毕后，换成step+1步的状态入队
			}
		}

	}
}

int main()
{
	cin >> n >> k;
	for(int i=1; i<=n; i++)
		for(int j=1; j<=n; j++)
			cin >> map[i][j];


	node a(3, 3, 0);
	st[a.x][a.y] = true; 
	q.push(a);
	bfs(a);
}

NOI6264走出迷宫

题目

代码

// NOI6262走出迷宫
#include<iostream>
#include<queue>
using namespace std;

const int N =  110;
char map[N][N];
int n, m;
bool st[N][N];
int dx[4] = {0,1,0,-1} ; 
int dy[4] = {1,0,-1,0} ;
int ans=0;

struct node
{
    int x, y, step;
    node(){}
    node(int xx, int yy, int stepp)
    {
        x = xx, y = yy, step = stepp;
    }
};

queue<node> q;
node a, b;

bool boundary(int x, int y)
{
    if(x >= 1 && x <= n && y >= 1 && y <= m) return true;
    else return false;
}

bool check(node i)
{
    return !st[i.x][i.y] && boundary(i.x, i.y) && map[i.x][i.y]!='#';
}

void bfs()
{
    while(q.size())
    {
        node t = q.front();
        q.pop();
        
        for(int k=0; k<4; k++)
        {
            node nt(t.x+dx[k], t.y+dy[k], t.step+1);
            if(check(nt))
            {
                st[nt.x][nt.y] = true;
                q.push(nt);
            }
        }
    
        if(t.x==b.x && t.y == b.y)
        {
            ans = t.step;
            break;
        } 
    }
}

int main()
{
    cin >> n >> m;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
        {
            cin >> map[i][j];
            if(map[i][j]=='S') a.x = i, a.y = j, a.step = 0;
            if(map[i][j]=='T') b.x = i, b.y = j, b.step = 0;     
        }

    st[a.x][a.y] = 1; // 表示起点已经被遍历过
    q.push(a);
    bfs();
    cout << ans;
}