小学期算法----广搜bfs

一、何为广度优先搜索

广度优先搜索：起点A

 A的邻接顶点入队; visited[A] 标记为true

 

 选择队列顶点front();  选定顶点B

 

 B的邻接顶点入队; visited[B] 设为true

 

 顶点移动到C；                C的邻接顶点入队;

 

 visited[C] 标记为true；重复以上步骤

 

 问题的本质就是让你在一幅「图」中找到 从起点start到终点target的最近距离 广搜的典型题目有： 走迷宫类，字符替换类，连连看，九宫格等等

二、bfs算法模板

 

 三、例题分析

·武士风度的牛

AcWing 188. 武士风度的牛 - AcWing

 ·乳草的入侵

189. 乳草的入侵 - AcWing题库

·立体推箱子

 AcWing 172. 立体推箱子 简单BFS（限制条件较多） - AcWing

游戏地图是一个 N 行 M 列的矩阵，每个位置可能是硬地（用 . 表示）、易碎地面（用 E 表示）、禁地（用 # 表示）、起点（用 X 表示）或终点（用 O 表示）。
你的任务是操作一个 1×1×2 的长方体。
这个长方体在地面上有两种放置形式，“立”在地面上（1×1 的面接触地面）或者“躺”在地面上（1×2 的面接触地面）。
在每一步操作中，可以按上下左右四个键之一。
按下按键之后，长方体向对应的方向沿着棱滚动 90 度。
任意时刻，长方体不能有任何部位接触禁地，并且不能立在易碎地面上。
字符 X 标识长方体的起始位置，地图上可能有一个 X 或者两个相邻的 X。
地图上唯一的一个字符 O 标识目标位置。
求把长方体移动到目标位置（即立在 O 上）所需要的最少步数。
在移动过程中，X 和 O 标识的位置都可以看作是硬地被利用

三维数组：横纵坐标和状态
bfs

限制条件有点多，分为立着 + 易碎地面 && 横着||纵着 + 两个坐标有任意一个点碰到了墙 && 有墙不能走 && 超出限定的范围 && 用三维数组标记当前状态 && 点阔以重复站但是状态不能一样

#include <cstdio>
#include <cstring>

const int N = 505, // 地图边长
// 存三个状态分别向上下左右扩展的偏移量
dx[3][4] = {       // x 坐标的偏移量
    {-2, 0, 1, 0}, // 0 向上扩展，x - 2，向左 x 不变，向下 x + 1，向右 x 不变
    {-1, 0, 2, 0}, // 1，同上
    {-1, 0, 1, 0}  // 2
}, dy[3][4] = {    // y 坐标的偏移量
    {0, -2, 0, 1},
    {0, -1, 0, 1},
    {0, -1, 0, 2}
}, dl[3][4] = {    // lie 的偏移量
    {1, 2, 1, 2},
    {0, 1, 0, 1},
    {2, 0, 2, 0}
};

struct State{int x, y, lie;}; // x, y 存坐标位置，lie 存箱子状态 (0, 1, 2)

int n, m;     // 存地图大小
int ex, ey;   // 存终点坐标
char g[N][N]; // 存地图
// dist 存到每个 State 的距离，dist[x][y][lie] 表示从初始状态到 坐标为 (x, y)，状态为 lie 的 State 的距离
int dist[N][N][3];

State q[3 * N * N]; // 广搜的队列。由于每个格上有三种状态，所以要开到 3 * 地图大小
int hh, tt;         // 队尾和队头

int bfs(int x, int y, int lie) // 传入初始坐标和状态
{
    hh = tt = 0;               // 将 hh 和 tt 重置为 0
    *q = (State){x, y, lie};   // {x, y, lie} 入队
    memset(dist, -1, sizeof dist); // 将到所有 State 的距离初始化为 -1
    dist[x][y][lie] = 0;       // 初始的 State 的距离初始化为 0
    while (hh <= tt)           // 开始广搜
    {
        State t = q[hh ++ ];   // 取出对头
        x = t.x, y = t.y, lie = t.lie; // 取出对头的坐标与状态
        if (x == ex && y == ey && !lie) return dist[x][y][lie]; // 如果立着到达终点了，那么返回该距离
        for (int i = 0; i < 4; i ++ )  // 向四个方向扩展
        {
            int nx = x + dx[lie][i];   // 求出向该方向扩展后的 x 坐标
            int ny = y + dy[lie][i];   // 求出 y 坐标
            int nlie = dl[lie][i];     // 求出 lie
            if (nx >= 0 && ny >= 0 && nx < n && ny < m) // 如果该坐标在地图内
            {
                if (g[nx][ny] == '#') continue;                  // 如果该格为禁地，那么跳过，进行下一重循环
                if (!nlie && g[nx][ny] == 'E') continue;         // 如果该状态为立在了易碎地，跳过
                if (nlie == 1 && g[nx + 1][ny] == '#') continue; // 如果该状态为竖着，且靠下的那格是禁地，那么跳过
                if (nlie == 2 && g[nx][ny + 1] == '#') continue; // 如果该状态为横着，且靠右的那个是禁地，那么跳过
                if (!~dist[nx][ny][nlie]) // 如果并非以上情况，且该 State 没有到过，
                {
                    dist[nx][ny][nlie] = dist[x][y][lie] + 1; // 那么记录到该 State 的距离，
                    q[ ++ tt] = (State) {nx, ny, nlie};       // State 入队
                }
            }
        }
    }
    return -1; // 如果无法立着到终点，返回 -1
}

int main()
{
    while (scanf("%d%d", &n, &m), n || m)
    {
        for (int i = 0; i < n; i ++ ) scanf("%s", g[i]);
        int x, y, lie; // 找初始的位置与状态
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < m; j ++ )
                if (g[i][j] == 'X') // 如果该格为起点
                {
                    x = i, y = j, g[i][j] = '.'; // 那么记录该格位置，将该格改为硬地
                    if (g[i + 1][j] == 'X') lie = 1, g[i + 1][j] = '.';      // 如果下面那格是硬地，那么 lie = 1，下面那格也制成 '.'
                    else if (g[i][j + 1] == 'X') lie = 2, g[i][j + 1] = '.'; // 否则如果左边那格硬地，那么 lie = 2，左边那格制成 '.'
                    else    lie = 0; // 否则 lie 制成 0
                }
                else if (g[i][j] == 'O') // 如果该格为终点
                    ex = i, ey = j, g[i][j] = '.'; // 那么记录该格位置，并把该格改为硬地
        int res=bfs(x, y, lie);        // bfs 一遍
        if (~res) printf("%d\n", res); // 如果返回值不为 -1，那么输出返回值
        else    puts("Impossible");    // 否则输出 Impossible
    }
    return 0;
}