C++图与深度优先

最新推荐文章于 2024-06-18 15:53:57 发布
最新推荐文章于 2024-06-18 15:53:57 发布
阅读量195 收藏
点赞数
分类专栏： c++ 数据结构与算法 编程 文章标签： 深度优先 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64530719/article/details/124891464
版权

目录

深度规则

寻路准备

1.真实地图

2.路线记录

3.起点 终点

4.坐标结构

5.方向结构

6.辅助地图

7.判断

8.探路用石头

9.寻路

10.路线的打印

总体

带权的图为网 边的长度

深度规则

方向 - 优先级

栈结构保存 先入后出 后入先出

寻路准备

1.真实地图

//真实地图
#define MAP_ROW 10
#define MAP_COL 10

2.路线记录

3.起点 终点

//起点 终点
	MyPoint beginPoint = { 2, 2 };
	MyPoint endPoint = { 8,8 };

4.坐标结构

//坐标结构
struct MyPoint
{
	int col, row;

};

5.方向结构

//方向 —— 枚举
enum Path_Dir
{
	P_UP,
	P_LEFT,
	P_DOWN,
	P_RIGHT //逆时针
};

6.辅助地图

//辅助地图 - 草稿地图
struct PathNode
{
	int val;//路况
	Path_Dir dir;
	bool isFind; //是否已走过

};

7.判断

//下一步能不能走
bool isMove(PathNode pArr[MAP_ROW][MAP_COL], int row,int col)
{
	//算法具有健壮性
	//判断 空地 是否已经走过
	if (row < 0 || row >= MAP_ROW || col < 0 || col >= MAP_COL)
	{
		return false;
	}
	else if (pArr[row][col].val == 0 && pArr[row][col].isFind == false)
	{
		return true;
	}
	return false;
}

8.探路用石头

//探路用石头
	MyPoint NearPoint = beginPoint;

9.寻路

//寻路 不知道多少步
	while (true)
	{
		//根据方向执行
		switch (pathArr[NearPoint.row][NearPoint.col].dir)
		{
		case P_UP:
			//改变方向
			pathArr[NearPoint.row][NearPoint.col].dir = P_LEFT;
			if (isMove(pathArr, NearPoint.row - 1, NearPoint.col))
			{
				//可以走，将当前位置设置为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
				//入栈
				MyPoint temp = { NearPoint.row - 1, NearPoint.col };
				mst.push(temp);
				NearPoint = temp;
			}
			break;
		case P_LEFT:
			//改变方向
			pathArr[NearPoint.row][NearPoint.col].dir = P_DOWN;
			if (isMove(pathArr, NearPoint.row , NearPoint.col-1))
			{
				//可以走，将当前位置设置为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
				//入栈
				MyPoint temp = { NearPoint.row , NearPoint.col-1 };
				mst.push(temp);
				NearPoint = temp;
			}
			break;
		case P_DOWN:
			//改变方向
			pathArr[NearPoint.row][NearPoint.col].dir = P_RIGHT;
			if (isMove(pathArr, NearPoint.row + 1, NearPoint.col))
			{
				//可以走，将当前位置设置为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
				//入栈
				MyPoint temp = { NearPoint.row + 1, NearPoint.col };
				mst.push(temp);
				NearPoint = temp;
			}
			break;
		case P_RIGHT:
			//不同 - 最后方向 死胡同 返回

			if (isMove(pathArr, NearPoint.row , NearPoint.col+1))
			{
				//可以走，将当前位置设置为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
				//入栈
				MyPoint temp = { NearPoint.row, NearPoint.col + 1 };
				mst.push(temp);
				NearPoint = temp;
			}
			else
			{
				//死胡同 退栈
				//这个位置要设为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
               //推栈
				MyPoint tempPoint = mst.top();
				cout << "退回 ：row -" << tempPoint.row << ", col -" << tempPoint.col << endl;
				mst.pop();
				//栈为空 找不到终点
				if (!mst.empty())
				{
					NearPoint = mst.top();
				}
				else{
					cout << "没有路了" << endl;
					return 0;
				}
			}
			break;
		default:
			break;
		}
		//找到终点了 
		if (NearPoint.row == endPoint.row&&NearPoint.col == endPoint.col)
		{
			break;
		}
	}

10.路线的打印

总体

#include <iostream>
#include <string>
using namespace std;

//真实地图
#define MAP_ROW 10
#define MAP_COL 10

//栈结构
#include<stack>

//坐标结构
struct MyPoint
{
	int col, row;

};
//方向 —— 枚举
enum Path_Dir
{
	P_UP,
	P_LEFT,
	P_DOWN,
	P_RIGHT //逆时针
};

//辅助地图 - 草稿地图
struct PathNode
{
	int val;//路况
	Path_Dir dir;
	bool isFind; //是否已走过

};

//下一步能不能走
bool isMove(PathNode pArr[MAP_ROW][MAP_COL], int row,int col)
{
	//算法具有健壮性
	//判断 空地 是否已经走过
	if (row < 0 || row >= MAP_ROW || col < 0 || col >= MAP_COL)
	{
		return false;
	}
	else if (pArr[row][col].val == 0 && pArr[row][col].isFind == false)
	{
		return true;
	}
	return false;
}

int main()
{
	//真实地图
	int mapArr[MAP_ROW][MAP_COL] = {
		{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
		{ 1, 0, 0, 0, 0, 1, 0, 0, 0, 1 },
		{ 1, 0, 0, 1, 0, 1, 0, 1, 0, 1 },
		{ 1, 0, 0, 1, 0, 1, 0, 0, 0, 1 },
		{ 1, 1, 1, 1, 0, 1, 0, 1, 0, 1 },
		{ 1, 0, 0, 0, 0, 1, 0, 1, 0, 1 },
		{ 1, 0, 1, 1, 0, 0, 0, 1, 0, 1 },
		{ 1, 0, 0, 1, 0, 1, 0, 1, 0, 1 },
		{ 1, 0, 0, 1, 0, 0, 0, 1, 0, 1 },
		{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
	};
	//栈结构
	stack<MyPoint> mst;

	//起点 终点
	MyPoint beginPoint = { 2, 2 };
	MyPoint endPoint = { 8,8 };
	//辅助地图
	PathNode pathArr[MAP_ROW][MAP_COL];
	//初始化
	for (int i = 0; i < MAP_ROW; i++)
	{
		for (int j = 0; j < MAP_COL; j++)
		{
			//三个信息初始化
			pathArr[i][j].isFind = false;
			pathArr[i][j].dir = P_UP;
			pathArr[i][j].val = mapArr[i][j]; //复制真实路况
		}
	}
	//起点入栈
	mst.push(beginPoint);
	//已走过判断基于离开这个位置
	//探路用石头
	MyPoint NearPoint = beginPoint;
	//寻路 不知道多少步
	while (true)
	{
		//根据方向执行
		switch (pathArr[NearPoint.row][NearPoint.col].dir)
		{
		case P_UP:
			//改变方向
			pathArr[NearPoint.row][NearPoint.col].dir = P_LEFT;
			if (isMove(pathArr, NearPoint.row - 1, NearPoint.col))
			{
				//可以走，将当前位置设置为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
				//入栈
				MyPoint temp = { NearPoint.row - 1, NearPoint.col };
				mst.push(temp);
				NearPoint = temp;
			}
			break;
		case P_LEFT:
			//改变方向
			pathArr[NearPoint.row][NearPoint.col].dir = P_DOWN;
			if (isMove(pathArr, NearPoint.row , NearPoint.col-1))
			{
				//可以走，将当前位置设置为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
				//入栈
				MyPoint temp = { NearPoint.row , NearPoint.col-1 };
				mst.push(temp);
				NearPoint = temp;
			}
			break;
		case P_DOWN:
			//改变方向
			pathArr[NearPoint.row][NearPoint.col].dir = P_RIGHT;
			if (isMove(pathArr, NearPoint.row + 1, NearPoint.col))
			{
				//可以走，将当前位置设置为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
				//入栈
				MyPoint temp = { NearPoint.row + 1, NearPoint.col };
				mst.push(temp);
				NearPoint = temp;
			}
			break;
		case P_RIGHT:
			//不同 - 最后方向 死胡同 返回

			if (isMove(pathArr, NearPoint.row , NearPoint.col+1))
			{
				//可以走，将当前位置设置为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
				//入栈
				MyPoint temp = { NearPoint.row, NearPoint.col + 1 };
				mst.push(temp);
				NearPoint = temp;
			}
			else
			{
				//死胡同 退栈
				//这个位置要设为已走
				pathArr[NearPoint.row][NearPoint.col].isFind = true;
               //推栈
				MyPoint tempPoint = mst.top();
				cout << "退回 ：row -" << tempPoint.row << ", col -" << tempPoint.col << endl;
				mst.pop();
				//栈为空 找不到终点
				if (!mst.empty())
				{
					NearPoint = mst.top();
				}
				else{
					cout << "没有路了" << endl;
					return 0;
				}
			}
			break;
		default:
			break;
		}
		//找到终点了 
		if (NearPoint.row == endPoint.row&&NearPoint.col == endPoint.col)
		{
			break;
		}
	}
  //打印地图
	cout << "----------------------\n";
	while (!mst.empty())
	{
		MyPoint tempPoint = mst.top();
		cout << "路线 ：row -" << tempPoint.row << ", col -" << tempPoint.col << endl;
		mst.pop();
	}
	system("pause");
	return 0;
}

 

Takasi711
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++深度优先搜索的实现方法
09-04
主要介绍了C++深度优先搜索的实现方法,是数据结构中非常重要的一种算法,需要的朋友可以参考下
C/C++实现图的深度优先遍历和广度优先遍历
12-26
C/C++实现图的深度优先遍历和广度优先遍历
C++算法之深度优先搜索算法
一个程序猿~
06-17 1220
深度优先搜索算法是图算法的一种，即DFS（Depth First Search）。其过程是对每个可能的分支路径深入直到不能再深入为止。本文会介绍深度优先搜索算法。
C++——深度优先搜索
m0_48748418的博客
05-21 3161
它从起始节点开始，沿着一条路径尽可能深地探索，直到无法继续或达到目标节点，然后回溯到前一节点，继续探索其他路径，直到遍历完所有节点或找到目标。在深度优先搜索中，每个节点都会被访问且仅被访问一次。如果某个节点的邻居节点已经被访问过，那么该节点将被跳过。在树的问题中，深度优先搜索可以用于查找树的特定节点或进行树的遍历。需要注意的是，深度优先搜索可能会陷入无限循环，因此在应用时需要合理设置终止条件和避免重复访问节点。3、若存在未访问的邻居节点，则选择一个作为当前节点，标记为已访问，并重复步骤2。
c++实现深度优先遍历
cooperdk的博客
09-22 332
本文将介绍如何使用C++实现图的深度遍历算法。深度遍历是一种从某个顶点出发，沿着图的边访问尽可能多的顶点的方法，如果到达某个顶点后没有未访问的相邻顶点，就回溯到上一个顶点，继续访问其他相邻顶点，直到所有顶点都被访问过为止。深度遍历可以用递归或栈来实现。我们可以用邻接表来存储这个图，邻接表是一个数组，每个元素是一个链表，表示一个顶点及其相邻的顶点。
c++实现深度优先搜索
weixin_48329769的博客
03-18 439
c++实现深度优先搜索
C++中的深度优先搜索算法
2301_77161129的博客
01-10 542
深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。这个算法会尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。C++中的深度优先搜索算法。
关于c++深度优先遍历
m0_71160915的博客
05-04 835
栈实现深度优先遍历的基本思路是：从起始节点开始，将其入栈，然后弹出栈顶元素并访问它，将其未访问的相邻节点入栈，重复这个过程直到栈为空。然后遍历当前节点的所有相邻节点，如果相邻节点未被访问过，则递归地访问它。深度优先遍历（Depth-First Search，DFS）是一种重要的图遍历算法，它可以用于解决很多问题，例如连通性问题、路径问题、生成树问题等。然后，当栈不为空时，弹出栈顶元素并访问它，将其未访问的相邻节点入栈。我们可以从一个起始节点开始，递归地访问其相邻节点，直到所有节点都被访问过。
【C++】图的深度优先遍历
Ll801003的博客
01-13 414
【代码】【C++】图的深度优先遍历。
用c++下dfs深度优先解决迷宫问题
qq_59143106的博客
03-19 373
【代码】用c++下dfs深度优先解决迷宫问题。
深度优先搜索详解 C++实现
SOUIC的博客
01-07 3319
DFS全文大概四千字左右，如果您初学DFS相信会对您会有很大的帮助，能力有限，很多术语不够专业，理解万岁
14-C++基本算法-深度优先搜索
mingfeng4923的博客
07-08 685
深度优先搜索是一种重要的算法思想，常用于解决图遍历、排列组合和搜索问题。通过递归和回溯的方式，我们可以遍历问题的所有可能解，并找到满足特定条件的解。通过以上的例子，我们掌握了深度优先搜索的基本原理和应用，希望能够在实际问题中灵活运用。⭐️希望本篇文章对你有所帮助。⭐️如果你有任何问题或疑惑，请随时向提问。
递归回溯深度优先搜索DFS练习题（含C++源码）
02-10
# 递归回溯深度优先搜索DFS算法练习题 C++ 含源码 包含题目：《过河卒》《出栈序列统计》《算24点》《冗余依赖》《走迷宫》《单项双轨道》《组合的输出》《售货员的难题》《驾车旅游》《关路灯》
c++ 马的深度优先搜索
03-16
深搜的应用，马的遍历
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5104
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
CF Round 944 （div.4）ABCDEFG
zaqjkl的博客
06-11 546
能够发生交换的ai和aj已经进行了限定只有ai XOR aj < 4之间的元素间可以交换，ai XOR aj < 4代表ai和aj二进制位只有后两位不同其他位相同，可以把只有后两位不同的数看成一个种类，无论数组中元素交换到什么位置，相互交换都只发生在同一种类中，所以只需要所有元素在输出时按要求分好种类，再在每个种类内部进行排序，输出时根据原本位置上数所属的种类依次从小到大输出对应种类内部排好序的元素即可。一种可行的解答方案是：枚举x(1<=x<=r)的值根据条件的变式。模板：是否是完全平方数。
算法笔记(二叉树1)
最新发布
weixin_64704029的博客
06-18 144
二叉树刷题
整数二分 个人见解
shallrelow的博客
06-15 1523
整数二分
CF33b-B. String Problem
Hanknet的博客
06-18 127
给定两个字符串，给出n个op。对于每个op可以将一种字母转变为另一个字母，代价为d。需要求出通过上面的变化，让两个字符串相等的最小代价的字符串。c0，那么总成本为dp[c1][c0] + dp[c2][c0];也就是c1变成c0的最小成本加上。接下来我们考虑某一个位置，假设初始字符分别是c1,c2，最后变成了。先用Floyd计算出一个字母变换为另一个字母的最小代价，c2变成c0的最小成本。
c++图的深度优先遍历算法
12-07
以下是C++图的深度优先遍历算法的示例代码： ```c++ #include #include #include using namespace std; const int MAXN = 1000; // 最大结点数 vector<int> node[MAXN]; // 存储结点关系 int vist[MAXN]; // ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值