最短路径 && 白骑士的移动(BFS)

最新推荐文章于 2024-11-10 21:43:58 发布
最新推荐文章于 2024-11-10 21:43:58 发布
阅读量330 收藏 3
点赞数
分类专栏： 学习 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46182401/article/details/105716791
版权

BFS

宽度优先搜索

在这里插入图片描述
在这里插入图片描述
*图片来源：挑战程序设计竞赛（第2版）

最短路径

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

（

http://m.blog.csdn.net/article/details?id=50768661。

）

#include <iostream>
#include <queue>
using namespace std;
const int MAX_N = 100;
const int MAX_M = 100;
const int INF = 0x3f3f3f3f;   //用来表示无穷大
typedef pair<int, int> P;   //定义一个坐标形式
char maze[MAX_N][MAX_M + 1];
int N, M;
int sx, sy; //起点的位置
int gx, gy; //终点的位置
 
int d[MAX_N][MAX_M];//储存起点到某一点的距离
int dx[4] = { 1,0,-1,0 }, dy[4] = { 0,1,0,-1 };  //移动方向
 
void bfs()
{
	queue<P> que;
	for (int i = 0; i < N; i++)
		for (int j = 0; j < M; j++)
			d[i][j] = INF;	     //将所有的点置空
	que.push(P(sx, sy));  //输入起点
	d[sx][sy] = 0;	    
 
	while (que.size())   //
	{
		P p = que.front(); que.pop(); //每一队都是一层（累积的距离相等），且只考虑一队
		int i;
		for (i = 0; i < 4; i++)		//输入目前这个点周围四个中没有被访问过的点
		{
			int nx = p.first + dx[i];
			int ny = p.second + dy[i];
			if (0 <= nx&&nx < N
				&& 0 <= ny&&ny < M
				&&maze[nx][ny] != '#'
				&&d[nx][ny] == INF)
		/*如果这个点（那四个点之一）
		1.在这个地图内
		2.这个点不是‘#’（不是墙）
		3.其值等于无穷大（未被访问过）
		*/
			{
				que.push(P(nx, ny));//满足以上条件即可进入队列
				d[nx][ny] = d[p.first][p.second] + 1; //目标位置下移了一次
				if(nx==gx && ny==gy) break;  //到了终点
 
                        }
		}
		if(i!=4) break;
	}
 
}
 
int main()
{
	cin>>N>>M;
	for (int i = 0; i < N; i++)
		cin>>maze[i];
	for (int i = 0; i < N; i++)
		for (int j = 0; j < M; j++)
		{
			if (maze[i][j] == 'S')
			{
				sx = i; sy = j;
			}
			if (maze[i][j] == 'G')
			{
				gx = i; gy = j;
			}
		}
	bfs();
	cout<<d[gx][gy]<<endl;
 
	return 0;
}

7-3 白骑士的移动 (20分)

小S第一次接触国际象棋。他发现国际象棋中的Knight棋子的移动方式和中国象棋中的马类似，移动方式如图所示。 QQ图片20191115182554.png

于是小S在棋盘上随意摆上了一些棋子，其中包括一枚白骑士、一枚黑皇后、若干黑战车和若干黑主教。

小S想知道，如何能在避开黑战车和黑主教的攻击范围的前提下，花费更少的步数吃掉黑皇后。

注1：战车的攻击范围呈直线，和中国象棋的車类似；主教的攻击范围呈斜线，无障碍物情况下可无限延伸。

注2：白骑士只能吃黑皇后，不可以吃掉黑战车和黑主教。

输入格式:
输入仅包含一组样例。

一组样例包含8行（分别对应1-8行），每行包含8个字符，每个字符代表对应行对应列的棋盘格子状况。

其中’ . ‘代表格子上没有摆放任何棋子；’ K '代表格子上摆放的是白骑士； ’ Q '代表格子上摆放的是黑皇后； ’ R '代表格子上摆放的是黑战车； ’ B '代表格子上摆放的是黑主教。

注：题目保证白骑士的初始位置不在黑战车和黑主教的攻击范围内。

输出格式:
如果白骑士可以在避开黑战车和黑主教的攻击的情况下吃掉黑皇后，则输出花费步数的最小值；否则输出"Checkmate"。

输入样例1:

R.B.QB.R
........
........
........
........
........
........
.K......

输出样例1:

4

输入样例2:

....RR.Q
........
.K......
........
........
........
........
........

输出样例2:

Checkmate

#include <iostream>
#include <queue>

using namespace std;

const int M = 8;
const int N = 8;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> P; //定义一个坐标形式
char MAP[M][N + 1];
int sx, sy;
int ex, ey;

int d[M][N];
int dx[8] = {-2, -1, 1, 2, -2, -1, 1, 2}, dy[8] = {1, 2, 2, 1, -1, -2, -2, -1};

void read_mark();
void bfs();

int main()
{

    read_mark();
    bfs();
    if(d[ex][ey] != INF)
    cout << d[ex][ey] << endl;
    else
    {
        cout << "Checkmate" << endl;
    }
    
}

void read_mark()
{
    for (int i = 0; i < M; i++)
        for (int j = 0; j < N; j++)
        {
            cin >> MAP[i][j];
        }

    for (int i = 0; i < M; i++)
        for (int j = 0; j < N; j++)
        {
            if (MAP[i][j] == 'K')
            {
                sx = i;
                sy = j;
            }

            if (MAP[i][j] == 'Q')
            {
                ex = i;
                ey = j;
            }

            if (MAP[i][j] == 'R') //战车攻击范围
                {
                    for (int ii = 0; ii < 8; ii++)
                {
                    if(MAP[i][ii] == 'Q' ||( MAP[i][ii] == 'R' && ii !=j) ||MAP[i][ii] == 'B' )
                        {break;}
                    else{
                        MAP[i][ii] = 'x';
                        
                    }
                     
                }
                for (int ii = 0; ii < 8; ii++)
                {
                    if(MAP[ii][j] == 'Q' ||MAP[ii][j] == 'B'||( MAP[ii][j] == 'R' && ii !=i))
                        break;
                    else {MAP[ii][j] = 'x';}
                }
                }
            

            if (MAP[i][j] == 'B') //主教攻击范围
            {
                
                int I = i+1, J = j+1;
                while (I < M && J <N && I >= 0 && J >= 0 && MAP[I][J] != 'B'&& MAP[I][J] != 'R'&& MAP[I][J] != 'Q')
                { MAP[I++][J++] = 'x';};
                
                I = i-1;J = j-1;
                while (I < M && J < N && I >= 0 && J >= 0 && MAP[I][J] != 'B'&& MAP[I][J] != 'R'&& MAP[I][J] != 'Q')
                {MAP[I--][J--] = 'x';};

                I = i-1;J = j+1;
                while (I < M && J < N && I >= 0 && J >= 0 && MAP[I][J] != 'B'&& MAP[I][J] != 'R'&& MAP[I][J] != 'Q')
                {MAP[I--][J++] = 'x';};

                I = i+1;J = j-1;
                while (I < M && J < N && I >= 0 && J >= 0 && MAP[I][J] != 'B'&& MAP[I][J] != 'R'&& MAP[I][J] != 'Q')
                {MAP[I++][J--] = 'x';};
            }
        }
    /*for (int i = 0; i < N; i++)
        {putchar('\n');
		for (int j = 0; j < M; j++)
        cout<<MAP[i][j];}*/
}

void bfs()
{
    queue<P> que;
	for (int i = 0; i < N; i++)
		for (int j = 0; j < M; j++)
			d[i][j] = INF;
   que.push(P(sx, sy));  //输入起点
	d[sx][sy] = 0;	  

    while (que.size())  
	{
		P p = que.front(); que.pop();
		int i;
		for (i = 0; i < 8; i++)		
		{
			int nx = p.first + dx[i];
			int ny = p.second + dy[i];
			if (0 <= nx&&nx < N
				&& 0 <= ny&&ny < M
				&& MAP[nx][ny] != 'x'
                && MAP[nx][ny] != 'B'
                && MAP[nx][ny] != 'R'
				&& d[nx][ny] == INF)
			{
				que.push(P(nx, ny));
				d[nx][ny] = d[p.first][p.second] + 1; 
				if(nx==ex && ny==ey) break; 
 
            }
		}
		if(i!=8) break;
	}
 
}
/*
R...R..Q
B.......
........
........
........
........
........
....K...

*/
Rise_wsc
关注
专栏目录
数据结构与算法——30. 广度、深度优先搜索及骑士周游问题
花城的博客
12-10 2806
文章目录一、广度优先搜索（Breadth First Search，BFS）1. BFS算法过程2. python实现3. 算法分析二、图的应用：骑士周游问题1. 构建骑士周游图2. 骑士周游问题算法实现3. 骑士周游问题算法分析与改进（1）算法分析（2）算法改进4. 启发式规则（heuristic）三、深度优先搜索（Depth First Search，DFS）1. python代码实现2. 算法分析 一、广度优先搜索（Breadth First Search，BFS） 在前面的词梯问题中，在单词关系图建
bsf dfs 专题（一）
qq_40980489的博客
08-08 1084
  写在前面：         广搜和深搜在算法入门中算难的一类，处理的问题的数量级也比较小，但仍是非常重要的算法思想。因为对于要用bfs和dfs解决的题，你如果不会基本模板，暴力也很难写出来，可以说白白丢到的题。所以即使bfs和dfs有一定的学习门槛，但我们仍要跨过，去了解掌握。       bfs：        通过这个专题的练习，我个人感觉广搜比深搜简单，广搜可谓万变不离其宗，同一...
BFS 骑士的移动
weixin_30595035的博客
07-26 133
骑士的移动 题目链接：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=83498#problem/E 题目： Description A friend of you is doing research on theTraveling Knight Problem (TKP)where you are to find th...
UVa439 Knight Move 骑士的移动(bfs)
timeruler的博客
10-26 382
题目大意：有一个8*8的国际象棋棋盘，输入起点和终点，问马最少走几步。 方法：用一次bfs，难点应该是计算最少步数，解决方法是设置一个层，每次遍历父节点周围的子节点就执行子节点的层=父节点的层+1，这样一来每个节点都有自己的层，每个节点都是公平的所以最后搜索出来直接就是最小步数。 代码： #include&lt;iostream&gt; #include &lt;string&gt; #i...
白骑士的移动（BFS）
纸短情长的博客
01-27 456
白骑士的移动 小S第一次接触国际象棋。他发现国际象棋中的Knight棋子的移动方式和中国象棋中的马类似，移动方式如图所示。 于是小S在棋盘上随意摆上了一些棋子，其中包括一枚白骑士、一枚黑皇后、若干黑战车和若干黑主教。 小S想知道，如何能在避开黑战车和黑主教的攻击范围的前提下，花费更少的步数吃掉黑皇后。 注1：战车的攻击范围呈直线，和中国象棋的車类似；主教的攻击范围呈斜线，无障碍物情况下可...
UVa 439骑士的移动（BFS）
weixin_30318645的博客
12-17 102
https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=380 做了这道题之后对BFS总算是有了点认识了。 1 #include<iostream> 2 #include<cstring> 3 us...
poj 1915 bfs(骑士移动)
丿聪丶
01-18 711
题意：给出棋盘上的初始点和终止点，求初始点到达终止点的最小步数。 思路：广搜求图上的最短步数，何为最短？就是每走一步都保证是往树的下一层走，那么到达终点的时候需要的步数就是最少的。那么就每走一个点就把下一次可能跳过的所有点的步数都加一，最后输出终止点存的步数即可。 #include #include using namespace std; int dir[8][2]={{-2,1},{-1,
Google 算法真题 20201
08-03
- 计算最少步数让白骑士到达黑骑士的位置，这涉及到图论和最短路径问题，如BFS或DFS。 13. **数字串压缩**： - 压缩数字序列，保持顺序不变，最小化新序列长度。可以使用哈希表和排序来实现。 14. **矩阵压缩**...
13_python_graph
weixin_43712064的博客
02-22 997
文章目录图的概念ADT Graph的实现图搜索算法广度优先搜索BFS深度优先搜索DFS骑士周游专用算法通用DFS图的应用词梯问题骑士周游问题初始算法Warnsdorff算法拓扑排序强连通分支最短路径问题最小生成树 图的概念 图可以用G=(V,E)来表述，对于图G,V是顶点的集合，E是边的集合。每个边是一个元组(v,w),v和w属于顶点集合V。 路径：由边依次连接起来的顶点序列。将路径定义为P=(...
python数据结构与算法分析（四）
yeqing1997的博客
01-21 1186
图
FZU 2180 骑士 （双向BFS）
换个姿势，再敲一次
07-04 972
Description 在一个5×5的棋盘上有12个白色的骑士和12个黑色的骑士， 且有一个空位。在任何时候一个骑士都能按照骑士的走法（它可以走到和它横坐标相差为1，纵坐标相差为2或者横坐标相差为2，纵坐标相差为1的格子）移动到空位上。 给定一个初始的棋盘，怎样才能经过移动变成如下目标棋盘： 为了体现出骑士精神，他们必须以最少的步数完成任务。 Input 第一行
poj 2243 bfs(还是骑士移动)
丿聪丶
01-18 555
这道题跟 1915 是一样的，通过这道题主要学习了 从字符串中分离出字母和数字的方法。 #include #include using namespace std; #define max 10 int dir[8][2]={{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,-1}}; int vis[max][max],step[max][
PTA白骑士的移动 (20分)
yan936462437的博客
01-28 582
白骑士的移动（20分） 小S第一次接触国际象棋。他发现国际象棋中的Knight棋子的移动方式和中国象棋中的马类似，移动方式如图所示。 于是小S在棋盘上随意摆上了一些棋子，其中包括一枚白骑士、一枚黑皇后、若干黑战车和若干黑主教。 小S想知道，如何能在避开黑战车和黑主教的攻击范围的前提下，花费更少的步数吃掉黑皇后。 注1：战车的攻击范围呈直线，和中国象棋的車类似；主教的攻击范围呈斜线，无障碍物情况下...
骑士问题-BFS求解
ACMer_wobudong的博客
06-29 2869
骑士问题 问题描述：在一个标准8*8的国际象棋棋盘上，棋盘中有些格子可能是有障碍物的。已知骑士的初始位置和目标位置，你的任务是计算出骑士最少需要多少步可以从初始位置到达目标位置。有障碍物的格子当然不可以到达。 标准的8*8的国际象棋棋盘中每一个格子可以用惟一的编号确定。行用1～8这8个数字依次表示，列用“a”～“h”这8个字母依次表示。例如图1(a)的骑士所在的位置（图中有n个格子）的编号为“d...
图论-BFS解无权有向图最短路径距离
bobkent的专栏
08-13 5867
概述本篇博客主要内容： 对广度优先搜索算法（Breadth-First-Search）进行介绍； 介绍用邻接表的存储结构实现一个图（附C++实现源码）； 介绍用BFS算法求解无权有向图（附C++实现源码）。 最后给出完整的代码和朋友们一起讨论进步。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
最新发布
qq_54375651的博客
11-10 1271
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
二分查找习题篇(上)
zoelinkailuo的博客
11-07 1003
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
AI 写作（三）文本生成算法：创新与突破（3/10）
小相探索IT世界
11-08 1660
本文深入探讨了 AI 写作中的多种文本生成算法。首先介绍了生成式与判别式模型的区别与特点，包括优化准则、对观察序列的处理、训练复杂度以及支持的训练方式等方面的差异，并对比了它们在 AI 写作中的优缺点。接着详细阐述了长短期记忆网络（LSTM）在文本生成中的应用，包括技术原理与结构、实现步骤与流程以及应用示例与效果。还深入分析了 Transformer 与自注意力机制，介绍了其模型架构与组成、自注意力机制的作用以及在 AI 写作中的重要作用。
数组类算法【leetcode】
随便写写
11-07 378
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值