BFS算法（蓝桥杯大胖子走迷宫为例）

最新推荐文章于 2024-06-15 15:20:41 发布

成、谋

最新推荐文章于 2024-06-15 15:20:41 发布

阅读量1.2k

点赞数

分类专栏：算法 DFS与BFS 文章标签：算法蓝桥杯宽度优先数据结构 bfs

本文链接：https://blog.csdn.net/m0_52124992/article/details/129991953

版权

算法同时被 2 个专栏收录

13 篇文章 2 订阅

订阅专栏

DFS与BFS

3 篇文章 0 订阅

订阅专栏

1、BFS算法思想

BFS算法，也称广度优先搜索算法，是一种经典的图搜索算法，其基本思想是从起点开始，逐层扩展搜索范围，直到找到目标节点或者整个图都被遍历过。

在BFS算法中，使用队列来存储待处理的节点，首先将起点加入队列中。然后，从队列中取出一个节点并遍历其所有邻居节点，将尚未访问的邻居节点加入队列中，直到队列为空或者找到目标节点。由于BFS算法采用逐层扩展的方式进行搜索，因此找到目标节点时，其与起点之间的路径一定是最短路径。

下面我们来看一下BFS算法的原理：

首先定义一个Queue类型的队列，将起点P入队。
取出队首节点，搜索该节点的所有邻居节点，并将尚未访问过的邻居节点都加入队列中。
判断目标节点是否在队列中，如果不在，则返回第2步。
如果目标节点已经在队列中，搜索结束。

BFS算法的时间复杂度通常为O(|V|+|E|)，其中|V|和|E|分别表示图的节点数和边数。在实际使用中，BFS算法常常用于求解最短路径问题，如迷宫游戏、路线规划等。

在实现BFS算法中，我们需要进行以下几个步骤：

定义一个队列Queue，用于存储待处理的节点。
定义一个数组visit，用于记录每个节点是否已经被访问过。
设定起点P为已访问，并将其加入队列中。
当队列非空时，取出队首节点，遍历其所有邻居节点，如果邻居节点尚未访问，则将其标记已访问，并加入队列中。
重复第4步，直到队列为空或者找到目标节点。

BFS模板

BFS算法：
  通常用队列（先进先出，FIFO）实现 
  初始化队列Q；
  Q = {起点s};
  标记s为已访问；
  while（Q非空）
  {
     取Q队首元素u；
     u出队；
     if（u==目标状态）
     {         ……
     }
     else
     {
         所有与u相邻且未被访问的点进入队列；
         标记u为已访问；
     }
 }

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

const int MAXN = 1005; // maximum number of nodes
vector<int> adj[MAXN]; // adjacency list
bool vis[MAXN]; // visited array

void bfs(int start) {
    queue<int> q;
    q.push(start);
    vis[start] = true;
    while (!q.empty()) {
        int curr = q.front();
        q.pop();
        // process current node here
        for (int neighbor : adj[curr]) {
            if (!vis[neighbor]) {
                q.push(neighbor);
                vis[neighbor] = true;
            }
        }
    }
}

int main() {
    // initialize adjacency list and visited array here
    bfs(start_node);
    return 0;
}

2、蓝桥杯大胖子走迷宫

题目描述

小明是个大胖子，或者说是个大大胖子，如果说正常人占用 1×1 的面积，小明要占用 5×5 的面积。

由于小明太胖了，所以他行动起来很不方便。当玩一些游戏时，小明相比小伙伴就吃亏很多。

小明的朋友们制定了一个计划，帮助小明减肥。计划的主要内容是带小明玩一些游戏，让小明在游戏中运动消耗脂肪。走迷宫是计划中的重要环节。

朋友们设计了一个迷宫，迷宫可以看成是一个由 n×n 个方阵组成的方阵，正常人每次占用方阵中 1×1 的区域，而小明要占用 5×5 的区域。小明的位置定义为小明最正中的一个方格。迷宫四周都有障碍物。

为了方便小明，朋友们把迷宫的起点设置在了第 3 行第 3 列，终点设置在了第 n−2 行第 n−2 列。

小明在时刻 0 出发，每单位时间可以向当前位置的上、下、左、右移动单位 1 的距离，也可以停留在原地不动。小明走迷宫走得很辛苦，如果他在迷宫里面待的时间很长，则由于消耗了很多脂肪，他会在时刻 k 变成一个胖子，只占用 3×3 的区域。如果待的时间更长，他会在时刻 2k 变成一个正常人，只占用 1×1 的区域。注意，当小明变瘦时迷宫的起点和终点不变。

请问，小明最少多长时间能走到迷宫的终点。注意，小明走到终点时可能瘦了也可能没有变瘦。

输入

输入的第一行包含两个整数 n , k（1≤n≤300，1≤k≤1000）。

接下来 n 行，每行一个由 n 个字符组成的字符串，字符为 + 表示为空地，字符为 * 表示为阻碍物。

输出

输出一个整数，表示答案。

样例输入

9 5
+++++++++
+++++++++
+++++++++
+++++++++
+++++++++
***+*****
+++++++++
+++++++++
+++++++++

样例输出

解题思路

不考虑小明的体积问题的话，其实就是一道经典的 BFS\DFS问题，即从起点走到终点的最小花费。这题在此基础上加上了人的体积，那么只需要在走的时候判断一下当前体积是否可以走到下一个位置。另外一个需要注意的点是可以原地踏步，所以每次把当前结点再加一次。

大佬的代码

#include <bits/stdc++.h>
#include <queue>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long LL;
int t,n,k,vis[1005][1005];//体重、行数、变瘦时间标记数组
char mp[400][400];//存图
//上下左右
const int dr[]= {0,0,-1,1};
const int dc[]= {-1,1,0,0};

struct node {
    int x,y,dis;
    node(int x=0,int y=0,int dis=0):x(x),y(y),dis(dis) {}
};
//在迷宫里饿死
bool inside(int xx, int yy) {
    if(xx+t/2<n && xx-t/2>=0 && yy+t/2<n && yy-t/2>=0) return true;//记得加上大胖子的身材
    else return false;
}
//大胖子卡住啦，动不了，只能在迷宫里饿一饿变瘦子
bool check(int xx,int yy) {
    for(int i=xx-t/2; i<=xx+t/2; i++)
        for(int j=yy-t/2; j<=yy+t/2; j++)
            if(mp[i][j]=='*') return false;
    return true;
}

void bfs() {
    queue<node> q;
    node u(2,2,0);//大胖子出发啦
    vis[2][2]=1;
    q.push(u);
    while(!q.empty()) {
        node u=q.front();
        q.pop();
        if(u.x==n-3 && u.y==n-3) {
            cout<<u.dis;
            return;
        }
                
        if(u.dis<k) t=5;//大胖子
        else if(u.dis>=k && u.dis<2*k) t=3;//胖子
        else if(u.dis>=2*k) t=1;//瘦子
        
        if(t!=1) q.push(node(u.x,u.y,u.dis+1));//胖子太胖啦，出不去，只能呆在原地 
        
        for(int i=0; i<4; i++) {
            int nx=u.x+dr[i];
            int ny=u.y+dc[i];
            if(inside(nx,ny) && !vis[nx][ny] && check(nx,ny)) {
                vis[nx][ny]=1;
                int diss=u.dis+1;
                node v(nx,ny,diss);
                q.push(v);
            }
        }
    }
}


int main() {
    cin>>n>>k;
    for(int i=0; i<n; i++)
        cin>>mp[i];
    bfs();
    return 0;
}