马的遍历（C++，BFS）

最新推荐文章于 2024-09-14 20:07:51 发布

WitheredSakura_

最新推荐文章于 2024-09-14 20:07:51 发布

阅读量852

点赞数 1

分类专栏： DFS与BFS 文章标签： c++ 宽度优先算法

本文链接：https://blog.csdn.net/m0_74036684/article/details/127895420

版权

DFS与BFS 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

题目描述

有一个 $\times m$ 的棋盘，在某个点 $(x, y)$ 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。

输入格式

输入只有一行四个整数，分别为 $n, m, x, y$ 。

输出格式

一个 $\times m$ 的矩阵，代表马到达某个点最少要走几步（不能到达则输出 $- 1$ ）。

样例 #1

样例输入 #1

3 3 1 1

样例输出 #1

0    3    2    
3    -1   1    
2    1    4

提示

数据规模与约定

对于全部的测试点，保证 $\leq x \leq n \leq 400$ ， $\leq y \leq m \leq 400$ 。

解题思路：

本题要求是找到到达每个点的最少步数

若对广度优先搜索（Breadth First Search）有所了解，则马上就会发现，广度优先搜索第一次到达所需的步数即为所要求的最小步数，那么我们需要做的就是用BFS去遍历每一个能够到达的点

这里进一步思考，可以认识到我们无需取消标记，也就是说我们没有递归返回操作

同时认识到数据量较大，容易发生爆栈

那么我们就可以用不定次数循环也就是while循环来实现广度优先搜索

接下来说明如何实现广度优先搜索

首先进行准备工作

创建一个队列，用于广度优先搜索

创建一个二维数组，用于存储到达每个点的最少步数

再创建一个二维数组，用于防止重复到达格子

再再创建一个二维数组，用于存储马能走的八种方向

准备工作完成

queue<node>bfs_queue;
int step_map[400][400] = { 0 };//用于记录到达每一个格子的步数
bool book_map[400][400] = { 0 };//用于判断是否重复到达
int step[8][2] =//大方向按照右、下、左、上的顺序，对于每个大方向，先上后下，先左后右
{
	{-1, 2},
	{1, 2},
	{2, -1},
	{2, 1},
	{-1, -2},
	{1, -2},
	{-2, -1},
	{-2, 1}
};

循环条件就是!bfs_queue.empty()，如果进一步强化条件，可以加上一个&& sum != N * M

接下来实现循环体

首先我们要尝试八个方向，判断每次尝试是否成功，若不成功，则尝试下一个方向

若成功，则将该方向入队，存储当前到达该位置需要的步数，标记该位置为已走过

八个方向尝试完毕后，不要忘记将队首出队

然后重复以上步骤即可，循环体实现完毕

while (!bfs_queue.empty() && sum != M * N)
{
	//循环主体
	for (int i = 0; i < 8; i++)//尝试八个方向
	{
		temp_node.m_x = bfs_queue.front().m_x + step[i][0];
		temp_node.m_y = bfs_queue.front().m_y + step[i][1];
		if (temp_node.m_x < 0 || temp_node.m_x > N - 1 || temp_node.m_y < 0 || temp_node.m_y > M - 1)//若出界，则尝试下一个方向
		{
			continue;
		}
		else if (book_map[temp_node.m_x][temp_node.m_y])//若走过，则尝试下一个方向
		{
			continue;
		}
		bfs_queue.push(temp_node);
		step_map[temp_node.m_x][temp_node.m_y] = step_map[bfs_queue.front().m_x][bfs_queue.front().m_y] + 1;//记录到达这个格子所需的步数，即为最小步数
		book_map[temp_node.m_x][temp_node.m_y] = true;//标记已走过
		sum++;
	}
	bfs_queue.pop();//八个方向尝试完毕，队首出队
}

至此，本题核心结题实现完毕

应该不会有人被输出卡住了吧（小声），只要”设置宽度为5+左对齐“就好啦

#include <iomanip>
for (int i = 0; i < N; i++)
{
	for (int j = 0; j < M; j++)
	{
		if (step_map[i][j] == 0)//将未到达的点修改为-1
		{
			if(i != start_x || j != start_y)//注意排除起点
			{
				step_map[i][j] = -1;
			}
		}
		cout << setw(5) << setiosflags(ios::left) << step_map[i][j];
	}
	cout << endl;
}

那么，本题的完整代码如下

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

struct node
{
	int m_x;
	int m_y;
};

queue<node>bfs_queue;
int step_map[400][400] = { 0 };//用于记录到达每一个格子的步数
bool book_map[400][400] = { 0 };//用于判断是否重复到达
int step[8][2] =//大方向按照右、下、左、上的顺序，对于每个大方向，先上后下，先左后右
{
	{-1, 2},
	{1, 2},
	{2, -1},
	{2, 1},
	{-1, -2},
	{1, -2},
	{-2, -1},
	{-2, 1}
};

int main()
{
	struct node temp_node;
	int N, M, start_x, start_y, sum = 0;//sum用于记录已经走过的格子数量
	cin >> N >> M;
	cin >> start_x >> start_y;
	temp_node.m_x = --start_x, temp_node.m_y = --start_y;
	bfs_queue.push(temp_node);//读入起始位置
	step_map[temp_node.m_x][temp_node.m_y] = 0;
	book_map[temp_node.m_x][temp_node.m_y] = 1;//注意要标记起点为已走过
 	sum++;
	while (!bfs_queue.empty() && sum != M * N)
	{
		//循环主体
		for (int i = 0; i < 8; i++)//尝试八个方向
		{
			temp_node.m_x = bfs_queue.front().m_x + step[i][0];
			temp_node.m_y = bfs_queue.front().m_y + step[i][1];
			if (temp_node.m_x < 0 || temp_node.m_x > N - 1 || temp_node.m_y < 0 || temp_node.m_y > M - 1)//若出界，则尝试下一个方向
			{
				continue;
			}
			else if (book_map[temp_node.m_x][temp_node.m_y])//若走过，则尝试下一个方向
			{
				continue;
			}
			bfs_queue.push(temp_node);
			step_map[temp_node.m_x][temp_node.m_y] = step_map[bfs_queue.front().m_x][bfs_queue.front().m_y] + 1;//记录到达这个格子所需的步数，即为最小步数
			book_map[temp_node.m_x][temp_node.m_y] = true;//标记已走过
			sum++;
		}
		bfs_queue.pop();//八个方向尝试完毕，队首出队
	}
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			if (step_map[i][j] == 0)//将未到达的点修改为-1
			{
				if(i != start_x || j != start_y)//注意排除起点
				{
					step_map[i][j] = -1;
				}
			}
			cout << setw(5) << setiosflags(ios::left) << step_map[i][j];
		}
		cout << endl;
	}
	return 0;
}