# 迷宫寻路三大算法(BFS,DFS,A*)

## BFS

bfs函数操作：
1，将节点添加到队列里面；
2，从队头取出节点将其访问状态设为1，判断其上下左右四个节点将符合要求的节点添加到队列中；
3，重复1，2操作直到从队列中取出的节点终点返回其dis；

``````#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string>
#include<string.h>
#include<algorithm>
#include<stack>
#include<queue>
#include<iterator>
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<point> 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

``````#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string>
#include<string.h>
#include<algorithm>
#include<stack>
#include<queue>
#include<iterator>
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]) { bfs(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最小的节点 将其四周可访问的节点添加到链表中 重复操作直到找到终点输出

``````#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string>
#include<string.h>
#include<algorithm>
#include<stack>
#include<list>
#include<queue>
#include<iterator>
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;
}``````

原文作者：BFS
原文地址: https://blog.csdn.net/Dog_dream/article/details/80270398
本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。