迷宫寻路三大算法(BFS,DFS,A*)
迷宫寻路
这是我们的数据结构作业本加我们自己再网上找算法记录下来，不过本人比较执着画了几天时间还是把这些算法自己写出来了。总得来说网上所说的大体算法应该就有三种（BFS，DFS，A*）
这里是一个验证网址是南阳OJ的一道题这是网址 http://acm.nyist.me/problem/58
好了不说废话开始吧
BFS
宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。
如上所示我要做的就是搜索整张，定义一个二维数组visit， visit[x][y]判断坐标x,y是否被访问，初始化visit为0都没有被访问；定义一个结构体point里面的参数有x,y,dis;其中x,y表示坐标，dis表示出发点到该节点的步数；
bfs函数操作：
1，将节点添加到队列里面；
2，从队头取出节点将其访问状态设为1，判断其上下左右四个节点将符合要求的节点添加到队列中；
3，重复1，2操作直到从队列中取出的节点终点返回其dis；
具体代码如下
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define MAX 10
int x, y, a, b;
struct point
{
int x, y, dis;//x坐标y坐标步数
};
int fx[4] = { -1,1,0,0 }, fy[4] = { 0,0,-1,1 };
int bfs(int x, int y,int maze[][9])
{
queue myque;
point tp;
tp.x = x;tp.y = y;tp.dis = 0;//初始化开始节点dis设为0
myque.push(tp);
while (!myque.empty())
{
tp = myque.front();myque.pop();//从队头取节点
if (tp.x == a && tp.y == b) { return tp.dis; }//判断是否到达目的地
for (int i = 0;i < 4;i++)
{
if (tp.x + fx[i] < 9 && tp.x + fx[i] >= 0 && tp.y + fy[i] < 9 &&
tp.y + fy[i] >= 0 && maze[tp.x + fx[i]][tp.y + fy[i]] == 0)
{
point tmp;
tmp.x = tp.x + fx[i];
tmp.y = tp.y + fy[i];
tmp.dis = tp.dis + 1;
maze[tmp.x][tmp.y] = 1;//添加进队列就将该位置设为1
myque.push(tmp);
}
}
}
}
int main()
{
int t;
cin >> t;
while (t--)
{
int maze[9][9] =
{ { 1,1,1,1,1,1,1,1,1 },
{ 1,0,0,1,0,0,1,0,1 },
{ 1,0,0,1,1,0,0,0,1 },
{ 1,0,1,0,1,1,0,1,1 },
{ 1,0,0,0,0,1,0,0,1 },
{ 1,1,0,1,0,1,0,0,1 },
{ 1,1,0,1,0,1,0,0,1 },
{ 1,1,0,1,0,0,0,0,1 },
{ 1,1,1,1,1,1,1,1,1 },
};
cin >> x >> y >> a >> b;
cout << bfs(x, y, maze) << endl;
}
return 0;
}
DFS
深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次.
顾名思义DFS就是从一个节点出发直到不能访问然后回转到上一层 也就是所说的 回溯+递归 实现方法就是从开始节点出发递归其四周只有满足要求就调用函数进行递归最后返回；所以我设置了两个数组dis，visit；dis存放步数，visit判断是否被访问；
具体代码
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define MAX 10
int maze[9][9] =
{ { 1,1,1,1,1,1,1,1,1 },
{ 1,0,0,1,0,0,1,0,1 },
{ 1,0,0,1,1,0,0,0,1 },
{ 1,0,1,0,1,1,0,1,1 },
{ 1,0,0,0,0,1,0,0,1 },
{ 1,1,0,1,0,1,0,0,1 },
{ 1,1,0,1,0,1,0,0,1 },
{ 1,1,0,1,0,0,0,0,1 },
{ 1,1,1,1,1,1,1,1,1 },
};
int x, y, a, b, dis[MAX][MAX],visit[MAX][MAX];
int dfs(int x, int y);
int next(int a,int b,int x, int y)
{
if (dis[x][y] > dis[a][b] + 1) //如果小于就要从这个点从新遍历
{
dis[x][y] = dis[a][b] + 1;//更新其值
visit[x][y] = 0;//将状态设为可访问 这步比较重要
}
if (!visit[x][y]) { dfs(x, y); }
return 0;
}
// 深度优先
int dfs(int x, int y)
{
visit[x][y] = 1;
if (x + 1 < 9 && maze[x + 1][y] == 0) //上
{
next(x, y, x + 1, y);
}
if (x - 1 >=0 && maze[x - 1][y] == 0) //下
{
next(x, y, x - 1, y);
}
if (y + 1 < 9 && maze[x][y + 1] == 0) //左
{
next(x, y, x, y+1);
}
if (y - 1 >=0 && maze[x][y - 1] == 0) //右
{
next(x, y, x, y-1);
}
return 0;
}
int main()
{
int t;
cin >> t;
while (t--)
{
memset(dis, 1, sizeof(dis));//初始化将dis的值设的比较大
memset(visit, 0, sizeof(visit));//初始化visit将所有值设为0
cin >> x >> y >> a >> b;
dis[x][y] = 0;
dfs(x, y);
cout << dis[a][b] << endl;
}
return 0;
}
##A算法##
A算法，A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。
A*算法就是对于每个节点设一个权值 F=G+H;G表示到开始节点的距离，H表示到终点的距离；然后从开始节点开始将可以访问的节点内添加到一个链表中 然后再从链表中取F最小的节点 将其四周可访问的节点添加到链表中 重复操作直到找到终点输出
这是大佬写的 A*算法
具体代码
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#define MAX 10
int fx[4] = { -1,1,0,0 }, fy[4] = { 0,0,-1,1 };
int sx, sy, ex, ey;
struct _NODE
{
int x;int y;//节点坐标
int dis;//节点的步数
int f;//权值
};
int cmp( _NODE a, _NODE b)
{
return a.f < b.f;
}
int weight(int x, int y)//高级算法不会 来个曼哈顿距离计算
{
return abs(x - sx) + abs(y - sy) + abs(x - ex) + abs(y - ey);
}
int fun_a(int maze[9][9])
{
_NODE sNode;
sNode.x = sx;sNode.y = sy;sNode.dis = 0;
sNode.f= weight(sNode.x, sNode.y);
maze[sNode.x][sNode.y] = 1;
list<_NODE> mylist;
mylist.push_back(sNode);//添加头结点
while (!mylist.empty())
{
mylist.sort(cmp);//按节点权值大小进行排序
sNode = mylist.front();mylist.pop_front();//从链表中取出节点
maze[sNode.x][sNode.y] = 1;//并将访问状态设为1
if (sNode.x == ex && sNode.y == ey)
{
return sNode.dis;
}
for (int i = 0;i < 4;i++)
{
if (sNode.x + fx[i] < 9 && sNode.x + fx[i] >= 0 && sNode.y + fy[i] < 9 &&
sNode.y + fy[i] >= 0 && maze[sNode.x + fx[i]][sNode.y + fy[i]] == 0) //判断路径是否可走
{
_NODE tp;
tp.x = sNode.x + fx[i];
tp.y = sNode.y + fy[i];
tp.f = weight(tp.x, tp.y); //计算节点的权值
tp.dis = sNode.dis + 1; //更新步数
mylist.push_back(tp);
}
}
}
return 0;
}
int main()
{
int t;
cin >> t;
while (t--)
{
int maze[9][9] =
{ { 1,1,1,1,1,1,1,1,1 },
{ 1,0,0,1,0,0,1,0,1 },
{ 1,0,0,1,1,0,0,0,1 },
{ 1,0,1,0,1,1,0,1,1 },
{ 1,0,0,0,0,1,0,0,1 },
{ 1,1,0,1,0,1,0,0,1 },
{ 1,1,0,1,0,1,0,0,1 },
{ 1,1,0,1,0,0,0,0,1 },
{ 1,1,1,1,1,1,1,1,1 },
};
cin >> sx >> sy >> ex >> ey;
cout << fun_a(maze) << endl;
}
return 0;
}
觉得自己还需要多加努力 水平有限 有大佬可以留言加已改进