关于广度优先搜索（BFS）的几个问题

已于 2024-08-07 17:32:30 修改
阅读量800 收藏 19
点赞数 9
文章标签： 宽度优先 算法
于 2024-08-07 14:32:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DaisyMaria/article/details/140904338
版权

BFS搜索主要用队列的数据结构。

1.数字操作

ccfffcd9ab1b475f9ed2ae45e94a904b.png

1a26d0c7616e48b7b6a154f399143158.jpeg

画了一个图来方便梳理理解过程

整体思路

  1. 初始化：从整数1开始，将其加入队列。

  2. BFS遍历：每次从队列中取出一个数，检查是否等于目标数n。如果等于，则返回当前步数。

  3. 扩展节点：如果不等于，则将当前数加1和乘2的结果（如果不超过n）加入队列，并标记这些数已访问，避免重复处理。

  4. 步数增加：每次处理完一层节点后，步数加1

 

时空复杂度

  • 时间复杂度：在最坏情况下，每个数最多被访问一次，时间复杂度为O(n)。

  • 空间复杂度：需要一个队列来存储当前层的所有数，以及一个数组来标记已访问的数，空间复杂度为O(n)。

 

代码

#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>
#include<queue>
using namespace std;

const int MAXN = 100000;
bool inQueue[MAXN + 1] = { false };

int getStep(int n) {
	int step = 0;
	queue<int> q;
	q.push(1);
	while (true)
	{
		int cnt = q.size();
		for (int i = 0; i < cnt; i++)
		{
			int front = q.front();
			q.pop();
			
			if (front == n)
			{
				return step;
			}

			inQueue[front] = true;

			if (front * 2 <= n && !inQueue[front * 2]) 
			{
				inQueue[front * 2] = true;
				q.push(front * 2);
			}

			if (front + 1 <= n && !inQueue[front + 1]) 
			{
				inQueue[front +1] = true;
				q.push(front + 1);
			}
		}
		step++;
	}
}

int main()
{
	int n, step = 0;
	scanf("%d", &n);
	printf("%d", getStep(n));
	return 0;
}

核心代码：

inQueue[front] = true;

if (front * 2 <= n && !inQueue[front * 2])
{
				inQueue[front * 2] = true;
				q.push(front * 2);
}

if (front + 1 <= n && !inQueue[front + 1])
{
				inQueue[front + 1] = true;
				q.push(front + 1);
}

step++;

运行时我对核心代码进行了改进，即在对数字进行 *2 / +1 操作前对数字是否已经进行过相关操作进行判断。比如第一次产生了两个2，其实第二个2完全没有必要再进行*2 / +1 操作，因为对比左边数字的树，我们可以发现这是重复操作，所以我把代码改成了（即增加了if(inQueue[front]==false)这一判断条件）：

if (inQueue[front] == false)
{
	inQueue[front] = true;

	if (front * 2 <= n && !inQueue[front * 2])
	{
		inQueue[front * 2] = true;
		q.push(front * 2);
	}

	if (front + 1 <= n && !inQueue[front + 1])
	{
		inQueue[front + 1] = true;
		q.push(front + 1);
	}
}
step++;

但最后的结果是，没有增加 if 条件判断的代码   运行时长比    添加的代码  要短，我思考不出结果，欢迎大家一起讨论

0526c58560134f93ae97486a8c8740e1.png

 

 

2.矩阵中的块

7e868c2a6a4b487e97fb914165247770.png

8995ccc8f1664a739224e01ce5837b0d.png

可以与上下左右四个方位构成“块”，单纯对角线构不成块

整体思路

  1. 初始化矩阵和辅助数据结构：

    • 读取输入矩阵的大小n和m，并初始化矩阵matrix。

    • 创建一个布尔数组inQueue，用于标记矩阵中的某个位置是否已经被访问过。

  2. 遍历矩阵：

    • 使用双重循环遍历矩阵中的每一个元素。

    • 如果当前元素是1且未被访问过，则从这个元素开始进行BFS。

  3. BFS过程：

    • 创建一个队列q，用于存储待访问的位置。

    • 将当前位置(x, y)加入队列，并标记为已访问。

    • 不断从队列中取出元素，检查其上下左右四个相邻位置。

    • 如果相邻位置是1且未被访问过，则将其加入队列并标记为已访问。

    • 访问。

  4. 统计“块”的数量：

    • 每次从新的未访问过的1开始进行BFS时，计数器加一。

    • 最终计数器的值即为矩阵中“块”的数量。

 

时空复杂度

  • 时间复杂度：O(n * m)，其中n是矩阵的行数，m是矩阵的列数。每个位置最多被访问一次。

  • 空间复杂度：O(n * m)，用于存储矩阵和辅助数据结构inQueue。

 

 代码

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>

#include <queue>

#include <utility>

using namespace std;



typedef pair<int, int> Position;



const int MAXN = 100;

int n, m, matrix[MAXN][MAXN];

bool inQueue[MAXN][MAXN] = { false };



const int MAXD = 4;

int dx[MAXD] = { 0, 0, 1, -1 };

int dy[MAXD] = { 1, -1, 0, 0 };



bool canVisit(int x, int y) 
{

    return x >= 0 && x < n && y >= 0 && y < m && matrix[x][y] == 1 && !inQueue[x][y];

}



void BFS(int x, int y) 
{

    queue<Position> q;

    q.push(Position(x, y));

    inQueue[x][y] = true;

    while (!q.empty()) {

        Position front = q.front();

        q.pop();

        for (int i = 0; i < MAXD; i++) 
        {

            int nextX = front.first + dx[i];

            int nextY = front.second + dy[i];

            if (canVisit(nextX, nextY)) 
            {

                inQueue[nextX][nextY] = true;

                q.push(Position(nextX, nextY));

            }

        }

    }

}



int main() {

    scanf("%d%d", &n, &m);

    for (int i = 0; i < n; i++) 
    {

        for (int j = 0; j < m; j++) 
        {

            scanf("%d", &matrix[i][j]);

        }

    }

    int counter = 0;

    for (int i = 0; i < n; i++) 
    {

        for (int j = 0; j < m; j++) 
        {

            if (matrix[i][j] == 1 && !inQueue[i][j]) 
            {

                BFS(i, j);

                counter++;

            }

        }

    }

    printf("%d", counter);

    return 0;

}

 

 

3.迷宫问题（最小步数）

c4ade23af1c44300a7192178c83e8ab8.png

4afbd3625b2d40e2b09d5cd01bb23f4d.png

 广度优先搜索（BFS）是一种图搜索算法，适用于在无权图中寻找最短路径。

在本题中，迷宫可以看作一个无权图，其中每个格子是一个节点，相邻的平地格子之间有边相连。

BFS通过逐层扩展的方式，确保找到的路径是最短的。

 

整体思路

  1. 初始化：从迷宫的左上角（起点）开始，将起点加入队列，并标记为已访问。

  2. 逐层扩展：使用队列进行BFS，每次从队列中取出一个节点，检查其是否为终点。如果是终点，则返回当前步数。

  3. 邻居节点处理：对于当前节点的每个合法邻居节点（即上下左右四个方向的平地格子），将其加入队列，并标记为已访问。

  4. 步数更新：每处理完一层节点，步数加一。

  5. 终止条件：如果队列为空且未找到终点，则返回-1，表示无法到达终点。

时空复杂度

  • 时间复杂度：O(n * m)，其中n和m分别是迷宫的行数和列数。每个节点最多被访问一次。

  • 空间复杂度：O(n * m)，用于存储迷宫信息和访问标记。

代码

#include <cstdio>

#include <queue>

#include <utility>

using namespace std;



typedef pair<int, int> Position;



const int MAXN = 100;

int n, m, maze[MAXN][MAXN];

bool inQueue[MAXN][MAXN] = { false };



const int MAXD = 4;

int dx[MAXD] = { 0, 0, 1, -1 };

int dy[MAXD] = { 1, -1, 0, 0 };



bool canVisit(int x, int y) {

    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !inQueue[x][y];

}



int BFS(int x, int y) 
{

    queue<Position> q;

    q.push(Position(x, y));

    inQueue[x][y] = true;

    int step = 0;

    while (!q.empty()) 
    {

        int cnt = q.size();//每一层需要探索的结点个数

        while (cnt--) 
        {

            Position front = q.front();

            q.pop();

            if (front.first == n - 1 && front.second == m - 1) {

                return step;

            }

            for (int i = 0; i < MAXD; i++) {

                int nextX = front.first + dx[i];

                int nextY = front.second + dy[i];

                if (canVisit(nextX, nextY)) {

                    inQueue[nextX][nextY] = true;

                    q.push(Position(nextX, nextY));

                }

            }

        }

        step++;//探索完一层后步数加一

    }

    return -1;

}



int main() {

    scanf("%d%d", &n, &m);

    for (int i = 0; i < n; i++) {

        for (int j = 0; j < m; j++) {

            scanf("%d", &maze[i][j]);

        }

    }

    int step = BFS(0, 0);

    printf("%d", step);

    return 0;

}

 本题中BFS核心代码（逐层搜索）：

while (!q.empty())      //
    {

        int cnt = q.size();//每一层需要探索的结点个数

        while (cnt--) //逐层搜索的关键
        {

            Position front = q.front();

            q.pop();

            if (front.first == n - 1 && front.second == m - 1) {

                return step;

            }

            for (int i = 0; i < MAXD; i++) {

                int nextX = front.first + dx[i];

                int nextY = front.second + dy[i];

                if (canVisit(nextX, nextY)) {

                    inQueue[nextX][nextY] = true;

                    q.push(Position(nextX, nextY));//实现广度搜索

                }

            }

        }

        step++;//探索完一层后步数加一

    }

之前的文章  深度优先搜索(DFS)的几个问题  中关于DFS的核心代码（递归回溯）：

for (int i = 0; i < MAXD; i++)        //依据下→上→右→左的顺序依次遍历，

{
        int nextX = x + dx[i];
        int nextY = y + dy[i];
        if (isValid(nextX, nextY))    //如果isValid判断无效则再次进入for循环换一个方向遍历

        {
            DFS(nextX, nextY, step + 1);//实现深度搜索
        }
}

 

4.迷宫最短路径

b8a483cca62c4026a607d6dd9dc43314.png 8f92c802ce7a409a89cb5f5661258668.png

 DFS最短路径需要不断比较得到的可能路径步数，然后用新的最短路径替代旧的最短路径。路径可以用vector实现（即）。BFS的路径存储可考虑记录前驱，然后回溯

整体思路

  1. 初始化：首先，我们需要读取迷宫的尺寸和布局，并初始化一些必要的变量和数据结构，如队列、访问标记数组和前驱数组。
  2. BFS搜索：从起点（左上角）开始，使用BFS逐步探索所有可能的路径。每次移动时，检查四个方向（上、下、左、右），并将合法的移动位置加入队列。
  3. 记录路径：在搜索过程中，记录每个位置的前驱位置，以便在找到终点后能够回溯出完整的路径。
  4. 输出路径：一旦到达终点（右下角），通过前驱数组回溯路径并输出。

时空复杂度

  • 时间复杂度：在最坏情况下，BFS需要遍历迷宫中的每一个位置，因此时间复杂度为O(n×m)，其中n和m分别是迷宫的行数和列数。
  • 空间复杂度：需要存储迷宫、访问标记、前驱数组和队列，因此空间复杂度也是O(n×m)。

代码 

#include <cstdio>
#include <queue>
#include <utility>
#include <algorithm>
using namespace std;

typedef pair<int, int> Position;

const int MAXN = 100;
int n, m, maze[MAXN][MAXN];
bool inQueue[MAXN][MAXN] = {false};
Position pre[MAXN][MAXN];

const int MAXD = 4;
int dx[MAXD] = {0, 0, 1, -1};
int dy[MAXD] = {1, -1, 0, 0};

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !inQueue[x][y];
}

void BFS(int x, int y) {
    queue<Position> q;
    q.push(Position(x, y));
    inQueue[x][y] = true;
    while (!q.empty()) {
        Position front = q.front();
        q.pop();
        if (front.first == n - 1 && front.second == m - 1) {
            return;
        }
        for (int i = 0; i < MAXD; i++) {
            int nextX = front.first + dx[i];
            int nextY = front.second + dy[i];
            if (canVisit(nextX, nextY)) {
                pre[nextX][nextY] = Position(front.first, front.second);
                inQueue[nextX][nextY] = true;
                q.push(Position(nextX, nextY));
            }
        }
    }
}

void printPath(Position p) {
    Position prePosition = pre[p.first][p.second];
    if (prePosition == Position(-1, -1)) {
        printf("%d %d\n", p.first + 1, p.second + 1);
        return;
    }
    printPath(prePosition);
    printf("%d %d\n", p.first + 1, p.second + 1);
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &maze[i][j]);
        }
    }
    fill(pre[0], pre[0] + n * m, Position(-1, -1));
    BFS(0, 0);
    printPath(Position(n - 1, m - 1));
    return 0;
}

本题的关键是以下代码：

void printPath(Position p) {
    Position prePosition = pre[p.first][p.second];
    if (prePosition == Position(-1, -1)) {
        printf("%d %d\n", p.first + 1, p.second + 1);
        return;
    }
    printPath(prePosition);
    printf("%d %d\n", p.first + 1, p.second + 1);
}

根据题目的输入案例，画图理解如下：

 e010c22f39f6481394c6acad6d5fa1f4.jpeg

 

5.跨步迷宫

015d3249f7184e5ab65ad0a63ba42a9e.png

586f0cfe4afd44619c4f5b3115373aea.png

这道题的关键点在于移动两格时，移动合法条件如何设置。 

我们可以根据题目中关于移动两格的限制条件设置：且只能移动到平地上（不允许跨越墙壁）

代码

#include <cstdio>
#include <queue>
#include <utility>
using namespace std;

typedef pair<int, int> Position;

const int MAXN = 100;
int n, m, maze[MAXN][MAXN];
bool inQueue[MAXN][MAXN] = { false };

const int MAXD = 8;
int dx[MAXD] = { 0,  0, 0,  0, 1, -1, 2, -2 };
int dy[MAXD] = { 1, -1, 2, -2, 0,  0, 0,  0 };

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !inQueue[x][y];
}

int BFS(int x, int y) {
    queue<Position> q;
    q.push(Position(x, y));
    inQueue[x][y] = true;
    int step = 0;
    while (!q.empty())
    {
        int cnt = q.size();
        while (cnt--)
        {
            Position front = q.front();
            q.pop();
            if (front.first == n - 1 && front.second == m - 1) {
                return step;
            }
            for (int i = 0; i < MAXD; i++) {
                int nextX = front.first + dx[i];
                int nextY = front.second + dy[i];
                int nextHalfX = front.first + dx[i] / 2;
                int nextHalfY = front.second + dy[i] / 2;
                if (canVisit(nextX, nextY)&&maze[nextHalfX][nextHalfY]==0) {
                    inQueue[nextX][nextY] = true;
                    q.push(Position(nextX, nextY));
                }
            }
        }
        step++;
    }
    return -1;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &maze[i][j]);
        }
    }
    int step=BFS(0, 0);
    printf("%d", step);
    return 0;
}

关键代码如下:

const int MAXD = 8;
int dx[MAXD] = { 0,  0, 0,  0, 1, -1, 2, -2 };
int dy[MAXD] = { 1, -1, 2, -2, 0,  0, 0,  0 };

.......

for (int i = 0; i < MAXD; i++) 
{
    int nextX = front.first + dx[i];
    int nextY = front.second + dy[i];
    int nextHalfX = front.first + dx[i] / 2;
    int nextHalfY = front.second + dy[i] / 2;
    if (canVisit(nextX, nextY)&&maze[nextHalfX][nextHalfY]==0) {
        inQueue[nextX][nextY] = true;
        q.push(Position(nextX, nextY));
    }
}

 

6. 字符迷宫

22e3b8eab848414fbf50c36c460f3b23.png

70fe82dbf8474e9583b9ce9ff2bc2536.png

这道题有两处亮点：

 ①输入的是字符。

为了减少工作量，可以继续使用之前的函数，但是要对输入的字符进行处理

②起点终点不再固定。

对输入的起点和终点进行保存，再传入函数。

代码

#include <cstdio>
#include <queue>
#include <utility>
using namespace std;

typedef pair<int, int> Position;

const int MAXN = 100;
int n, m, maze[MAXN][MAXN];
bool inQueue[MAXN][MAXN] = { false };

const int MAXD = 4;
int dx[MAXD] = { 0,  0, 1, -1};
int dy[MAXD] = { 1, -1, 0, 0 };

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !inQueue[x][y];
}

int BFS(Position start,Position target) {
    queue<Position> q;
    q.push(start);
    inQueue[start.first][start.second] = true;
    int step = 0;
    while (!q.empty())
    {
        int cnt = q.size();
        while (cnt--)
        {
            Position front = q.front();
            q.pop();
            if (front==target) {
                return step;
            }
            for (int i = 0; i < MAXD; i++) 
            {
                int nextX = front.first + dx[i];
                int nextY = front.second + dy[i];
      
                if (canVisit(nextX, nextY)) {
                    inQueue[nextX][nextY] = true;
                    q.push(Position(nextX, nextY));
                }
            }
        }
        step++;
    }
    return -1;
}

int main() {
    Position start, target;
    char c;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) 
    {
        getchar();
        for (int j = 0; j < m; j++) 
        {
            scanf("%c", &c);
            if (c == '.')
                maze[i][j] = 0;
            else if (c == '*')
                maze[i][j] = 1;
            else if (c == 'S')
                start = Position(i, j);
            else if (c == 'T')
                target = Position(i, j);
        }
    }
    int step = BFS(start, target);
    printf("%d", step);
    return 0;
}

 

7.多终点迷宫问题

04e8c664257647129080979d3da93c6e.png

这道题没有什么特别的，就是在每到达一个之前没到达的点时要注意把此时对应的步数存储好

代码

#include <cstdio>
#include <cstring>
#include <queue>
#include <utility>
#include<algorithm>
using namespace std;

typedef pair<int, int> Position;

const int INF = 0x3f;
const int MAXN = 100;
int n, m, maze[MAXN][MAXN];
bool inQueue[MAXN][MAXN] = { false };
int minStep[MAXN][MAXN];

const int MAXD = 4;
int dx[MAXD] = { 0,  0, 1, -1};
int dy[MAXD] = { 1, -1, 0, 0 };

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && maze[x][y] == 0 && !inQueue[x][y];
}

void BFS(int x,int y) {
    memset(minStep, -1, sizeof(minStep));
    queue<Position> q;
    q.push(Position(x,y));
    inQueue[x][y] = true;
    minStep[x][y] = 0;
    int step = 0;
    while (!q.empty())
    {
        int cnt = q.size();
        while (cnt--)
        {
            Position front = q.front();
            q.pop();
        
            for (int i = 0; i < MAXD; i++) 
            {
                int nextX = front.first + dx[i];
                int nextY = front.second + dy[i];
                if (canVisit(nextX, nextY)) {
                    inQueue[nextX][nextY] = true;
                    minStep[nextX][nextY] = step + 1;
                    q.push(Position(nextX, nextY));
                }
            }
        }
        step++;
    }
}

int main() {
   
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) 
    {
        for (int j = 0; j < m; j++) 
        {
            scanf("%d", &maze[i][j]);
        }
    }
    BFS(0, 0);

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            printf("%d", minStep[i][j]);
            printf(j < m - 1 ? " " : "\n");
        }
    }

    return 0;
}

 

8. 迷宫问题-传送点

9d399ba5ee17499aa9768f6a33c38b3c.png

12ecbeca92cf4f68a82f3630c6b900b4.png

这道题比较特殊的点在于如何处理这个传送关系，BFS的“地毯式”搜索可以让我们不用考虑“是否传送”，遇到传送点把它放进路径队列里就可以了。

传送点怎么处理可以考虑用map函数形成映射关系。 

代码

#include <cstdio>
#include <queue>
#include <utility>
#include <map>
using namespace std;

typedef pair<int, int> Position;

const int MAXN = 100;
int n, m, maze[MAXN][MAXN];
bool inQueue[MAXN][MAXN] = { false };
map<Position, Position> transMap;

const int MAXD = 4;
int dx[MAXD] = { 0,  0, 1, -1};
int dy[MAXD] = { 1, -1, 0, 0 };

bool canVisit(int x, int y) 
{
    return x >= 0 && x < n && y >= 0 && y < m &&(maze[x][y] == 0 || maze[x][y] == 2) && !inQueue[x][y];
}

int BFS(int x,int y) 
{
    queue<Position> q;
    q.push(Position(x,y));
    inQueue[x][y] = true;

    int step = 0;
    while (!q.empty())
    {
        int cnt = q.size();

        while (cnt--)
        {
            Position front = q.front();
            q.pop();

            if (front.first == n - 1 && front.second==m-1) 
            {
                return step;
            }
        
            for (int i = 0; i < MAXD; i++) 
            {
                int nextX = front.first + dx[i];
                int nextY = front.second + dy[i];

                if (canVisit(nextX, nextY)) 
                {
                    inQueue[nextX][nextY] = true;
                    q.push(Position(nextX, nextY));

                    if (maze[nextX][nextY] == 2) 
                    {
                        Position transPosition = transMap[Position(nextX, nextY)];
                        inQueue[transPosition.first][transPosition.second] = true;
                        q.push(transPosition);
                    }
                }
            }
        }
        step++;
    }

    return -1;
}

int main() {
   
    vector<Position> transVector;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) 
    {
        for (int j = 0; j < m; j++) 
        {
            scanf("%d", &maze[i][j]);
            if (maze[i][j] == 2) {
                transVector.push_back(Position(i, j));
            }
        }
    }

    transMap[transVector[0]] = transVector[1];
    transMap[transVector[1]] = transVector[0];

    int step=BFS(0, 0);

    printf("%d", step);

    return 0;
}

关键代码：

map<Position, Position> transMap;

......

if (canVisit(nextX, nextY)) 
{
    inQueue[nextX][nextY] = true;
    q.push(Position(nextX, nextY));

    if (maze[nextX][nextY] == 2) 
    {
        Position transPosition = transMap[Position(nextX, nextY)];
        inQueue[transPosition.first][transPosition.second] = true;
        q.push(transPosition);
    }
}

......

int main()

{
    vector<Position> transVector;
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) 
    {
        for (int j = 0; j < m; j++) 
        {
            scanf("%d", &maze[i][j]);
            if (maze[i][j] == 2) {
                transVector.push_back(Position(i, j));
            }
        }
    }

    transMap[transVector[0]] = transVector[1];
    transMap[transVector[1]] = transVector[0];
......

}

 

 9.中国象棋-马-无障碍

5978dc3810d64442b73b2e0472b23f39.png

874952d7aa324673b737b4f58a5129d1.png

 

“马踏棋盘”与7.多终点迷宫问题相似，差别在于移动位置的设置（可参考5.跨步迷宫）

代码

#include <cstdio>
#include <cstring>
#include <queue>
#include <utility>
#include<algorithm>
using namespace std;

typedef pair<int, int> Position;

const int MAXN = 100;
int n, m;
bool inQueue[MAXN][MAXN] = { false };
int minStep[MAXN][MAXN];

const int MAXD = 8;
int dx[MAXD] = { -2, -1, 1, 2, -2, -1, 1, 2 };
int dy[MAXD] = { 1, 2, 2, 1, -1, -2, -2, -1 };

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && !inQueue[x][y];
}

void BFS(int x, int y) {
    memset(minStep, -1, sizeof(minStep));
    queue<Position> q;
    q.push(Position(x, y));
    inQueue[x][y] = true;
    minStep[x][y] = 0;
    int step = 0;

    while (!q.empty())
    {
        int cnt = q.size();
        while (cnt--)
        {
            Position front = q.front();
            q.pop();

            for (int i = 0; i < MAXD; i++)
            {
                int nextX = front.first + dx[i];
                int nextY = front.second + dy[i];
                if (canVisit(nextX, nextY)) {
                    inQueue[nextX][nextY] = true;
                    minStep[nextX][nextY] = step + 1;
                    q.push(Position(nextX, nextY));
                }
            }
        }
        step++;
    }
}

int main() {

    int x, y;
    scanf("%d%d%d%d", &n, &m, &x, &y);

    BFS(x-1,y-1);

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            printf("%d", minStep[i][j]);
            printf(j < m - 1 ? " " : "\n");
        }
    }

    return 0;
}

 

10.中国象棋-马-有障碍

0b2d85adf2e845b5b3fbad7ea87ffa59.png

18c170cf57d44b078038c11a18d005b7.png

e16c4d90a78544bb901dab0c442d4ad7.png

“马踏棋盘”与7.多终点迷宫问题相似，差别在于移动位置的设置（可参考5.跨步迷宫），比9.多了障碍设置，可以增加移动条件。

代码

#include <cstdio>
#include <cstring>
#include <queue>
#include <utility>
#include <map>
using namespace std;

typedef pair<int, int> Position;

const int MAXN = 100;
int n, m;
bool inQueue[MAXN][MAXN] = { false };
int minStep[MAXN][MAXN];
map<Position, bool> isBlock;

const int MAXD = 8;
int dx[MAXD] = { -2, -1, 1, 2, -2, -1, 1, 2 };
int dy[MAXD] = { 1, 2, 2, 1, -1, -2, -2, -1 };

bool canVisit(int x, int y) {
    return x >= 0 && x < n && y >= 0 && y < m && !inQueue[x][y] && !isBlock[Position(x, y)];
}

void BFS(int x, int y) {
    memset(minStep, -1, sizeof(minStep));
    queue<Position> q;
    q.push(Position(x, y));
    inQueue[x][y] = true;
    minStep[x][y] = 0;
    int step = 0;

    while (!q.empty())
    {
        int cnt = q.size();
        while (cnt--)
        {
            Position front = q.front();
            q.pop();

            for (int i = 0; i < MAXD; i++)
            {
                int nextX = front.first + dx[i];
                int nextY = front.second + dy[i];
                if (canVisit(nextX, nextY)&&!isBlock[Position(front.first+dx[i]/2,front.second+dy[i]/2)])
                {
                    inQueue[nextX][nextY] = true;
                    minStep[nextX][nextY] = step + 1;
                    q.push(Position(nextX, nextY));
                }
            }
        }
        step++;
    }
}

int main() {

    int x, y;
    scanf("%d%d%d%d", &n, &m, &x, &y);

    int k, blockX, blockY;
    scanf("%d", &k);
    for (int i = 0; i < k; i++)
    {
        scanf("%d%d", &blockX, &blockY);
        isBlock[Position(blockX - 1, blockY - 1)] = true;
    }

    BFS(x-1,y-1);

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            printf("%d", minStep[i][j]);
            printf(j < m - 1 ? " " : "\n");
        }
    }

    return 0;
}

bool类型的默认初始化值是false。

 

Hilda Leung
关注
C/C++ 广度优先搜索BFS算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
07-01 533
BFS算法的优点是能够找到起点到目标节点的最短路径，而且可以应用于非加权图和加权图，并且找到的路径是无环的。BFS算法的优点是能够找到起点到目标节点的最短路径，而且可以应用于非加权图和加权图，并且找到的路径是无环的。BFS算法的优点是能够找到起点到目标节点的最短路径，而且可以应用于非加权图和加权图，并且找到的路径是无环的。BFS算法的优点是能够找到起点到目标节点的最短路径，而且可以应用于非加权图和加权图，并且找到的路径是无环的。BFS算法的基本思想是通过队列实现，逐层遍历图中的各个节点。
广度优先搜索(BFS) 详解
fhgzs_xyh的博客
06-26 5929
很多搜索算法都是广度优先搜索的变形，用广度优先搜索求最短路等问题会快很多，所以广度优先搜索是个很重要的算法 原创代码，搬运需经本人允许
广度优先搜索（BFS）算法
最新发布
beenles的博客
06-07 3978
广度优先搜索算法（BFS）是一种用于遍历图形结构的算法，它从一个起始顶点开始，先依次访问这个顶点的所有邻居顶点，然后再按照距离逐层遍历图中的所有顶点。BFS算法使用队列数据结构来实现，在访问完一个顶点后，将其未被访问的邻居加入队列中，并标记为已访问，然后从队列中取出下一个未被访问的顶点，重复以上过程，直到队列为空为止。BFS算法可以用于解决图中的许多问题，例如找出两个顶点之间的最短路径、判断图是否为二分图等。BFS算法的时间复杂度为O(V+E)，其中V为顶点数，E为边数。
BFS、DFS复杂度分析（时间、空间）
Patience
07-15 2万+
BFS的复杂度分析。 BFS是一种借用队列来存储的过程，分层查找，优先考虑距离出发点近的点。无论是在邻接表还是邻接矩阵中存储，都需要借助一个辅助队列，v个顶点均需入队，最坏的情况下，空间复杂度为O（v）。 邻接表形式存储时，每个顶点均需搜索一次，时间复杂度T1=O（v），从一个顶点开始搜索时，开始搜索，访问未被访问过的节点。最坏的情况下，每个顶点至少访问一次，每条边至少访问1次，这是因为在搜索的过程中，若某结点向下搜索时，其子结点都访问过了，这时候就会回退，故时间复 杂度为O(E)，算法总的时间复 度为
广度优先和深度优先的时间复杂度以及空间复杂度(更新)
RUN
12-26 2万+
DFS和BFS时间复杂度：O（n） 因为这是树 遍历，我们必须触摸每个节点，使这个O（n），其中n是树中的节点数。 BFS空间复杂度：O（n） BFS必须至少存储队列中整个树的级别（样本 队列实施）。使用完美的完全平衡二叉树，这将是（n / 2 + 1）个节点（最后一个级别）。 最佳案例 （在此上下文中），树严重不平衡，每层只包含1个元素，空间复杂度为O（1）。 最坏的情况下 将存储（n-1）个节点与一个相当无用的N-ary树，其中除根节点之外的所有节点都位于第二级。 DFS空间复杂度：O（d） 无论实现（
图的遍历（图上BFS、DFS）
qq_61540355的博客
07-06 307
图的遍历
图dfs和bfs时的时间复杂度
wusecaiyun的专栏
11-01 3万+
下图摘自严蔚敏的教材： 上面说的是DFS。 下面说的是BFS。
MATLAB源码集锦-基于BFS广度优先搜索算法代码
02-14
其中，BFS（广度优先搜索）是一种常用的策略。本资源“MATLAB源码集锦-基于BFS广度优先搜索算法代码”是专门为MATLAB用户提供的，旨在帮助他们理解和实现BFS算法。 BFS算法的基本思想是从起点开始，首先访问其所有...
BFS 广度优先搜索算法 matlab
02-22
**广度优先搜索(Breadth-First Search, BFS)**是一种在图或树中搜索节点的算法，它按照从根节点开始，逐层扩展的方式进行。在MATLAB中实现BFS，可以帮助我们解决许多问题，例如查找最短路径、判断图的连通性等。 ...
【广度优先搜索BFS】广度优先搜索基本思想
qq_42397914的博客
04-20 1765
搜索是常见的解决问题的方法，常见的搜索方式有深度优先搜搜和广度优先搜索，一般来说都是搜索只不过方式略有不同，所以我之前在学习搜索的时候一直都是练习的深度优先搜索，也很少有哪些问题就必须用深度优先或者广度优先，否则就解不出来的，基本上会一种我感觉也差不多，但是呢，有的问题他还是最好用相应的解法效率更高一些，所以就来补补广度优先搜索。 【广度优先搜索（BFS）】 广度优先搜索BFS（Breadth F...
BFS 宽度优先搜索 算法摘记
小人物的草稿本
08-14 3771
源自网络与书籍   自己学习 算法摘记
bfs时间复杂度及优化方向
Acnext的博客
08-14 6683
个人对bfs的时间复杂度以前总是不太会分析 总以为时间复杂度就是 O（总的状态数） 对于一些简单的问题（状态数很少的问题）这么近似的确可以 但是随着题目做的多了 有时候 对于状态数 为1e7 1e8 的题目 觉得能1s过 却发现会‘迷之’tle  其实tle是理所应当的 下面说一下对于bfs 时间复杂度的新认识 ： bfs 的复杂度 大体由两点决定 1.状态数2.转移代价（由一种状态到另一种状
深度优先算法（DFS）和广度优先算法（BFS）时间复杂度和空间复杂度计算精讲
JiajunSun的博客
05-18 6806
现在我们设定任务为到山东菏泽曹县买牛逼，需要利用深度优先算法（DFS）和广度优先算法(BFS)在中国、省会、市、区县这张大的树中搜索到曹县，那么这个任务Goal就是找到曹县。 假如图的最大路径长度m和最大分支因子b 先用DFS计算时间复杂度和空间复杂度 时间复杂度（算法对大小为n-T的实例执行基本操作的次数(n)）: 考虑最坏情况，也就是说我们找了整张中国地图的区县最后才找到山东菏泽曹县。时间复杂度就是找每个节点这个过程的数量，总共找了的次数，就是图中弧的个数。 按最坏情况每个节点的最大分支因子都是b，
广度优先和深度优先树遍历的时间和空间复杂度是多少？
jfkidear的专栏
04-21 2万+
题 广度优先和深度优先树遍历的时间和空间复杂度是多少？ 有人可以用一个例子来解释我们如何计算这两种遍历方法的时间和空间复杂度？ 此外，深度优先遍历的递归解决方案如何影响时间和空间复杂度？ 20 2018-03-23 17:56 起源 维基百科上提供了相当不错的解释： en.wikipedia.org/wiki/Depth-firs...
【算法】图的 深度优先搜索 广度优先搜索 复杂度分析 python代码实现
scxyz的博客
04-10 7272
深度优先搜索算法和广度优先搜索算法都是基于“图”这种数据结构的。 作为图的搜索算法，既可用于有向图，也可用于无向图，以下均用无向图讲解。 广度优先搜索 Breadth-First-Search，BFS。 一种“地毯式”层层推进的搜索策略，先查找离起始顶点最近的，然后是次近的，依次往外搜索。 s 表示起始顶点，t 表示终止顶点。搜索一条从 s 到 t 的路径。 实际上，求得的路径就是从 s 到 t ...
图的深度优先遍历与广度优先遍历及其复杂度分析
Dragon_i的博客
12-13 3万+
这里放一下关于图的遍历 废话少说直接上~~ 首先是图的结构类型: typedef struct ANode{ int adjvex; //编号 struct ANode *nextarc; //链接指针 Elemtype weight; //权值 }ArcNode; typedef struct VNode{ Elemtyp...
时间复杂度和空间复杂度的简单讲解
热门推荐
HaloTrriger的博客
01-07 5万+
一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。 把今年很流行，淡淡的基佬紫送给各位看官，原谅绿就算了,怕被打死。 文章最后，举例使用二分查找和斐波那契的递归和迭代方法，分别说明时间和空间复杂度。 时间复杂度： 首先要说的是，时间复杂度的计算并不是计算程序具体运行的时间，而是算法执行语句的次数。 当我们面前有多个算法时，我们可以通过计算时间复杂度，判断出哪一
双向BFS中复杂度的理解
qq_31839461的博客
10-20 1015
刚见到双向BFS的时候一直关于复杂度有一些点不是很理解，比如说一个三叉树，假设之间的路径为4，那么如果单项BFS的话，算法的复杂度应该是(1+3+3^2+3^3+3^4) = (3^5-1)/2 数量级就是O(n^(m+1))，n指的就是单个节点可以走的方向的个数，m指的就是路径的长度，假如是迷宫问题，n=4 如果是双向的话，假设两边都遍历了两层，此时复杂度是(1+3+3^2)*2，我们这里定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值