仙岛寻药 BFS，A*（Astar）算法

题目地址（推荐acwing）

从题目可简单看出，这是个典型的搜索题，可以直接用BFS暴力搜索。代码如下：

#include<iostream>
#include<stdio.h>
#include<queue>
#include<cstring>
using namespace std;
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}},r,l;//二维数组存方向
char map[305][305];
bool j[305][305];
struct node
{
	int x,y,step;
}s,e,temp;
int bfs(node s)
{
	queue <node> q;
	q.push(s);
	while(!q.empty())//队列非空就一直搜索，因为队列是先进先出，所以一旦达到终点就是最短路径
	{
		for(int i=0;i<4;i++)
		{
			temp.x=q.front().x+dir[i][0];
			temp.y=q.front().y+dir[i][1];
			temp.step=q.front().step+1;
		if(temp.x>=1&&temp.x<=l&&temp.y>=1&&temp.y<=r&&map[temp.x][temp.y]!='#'&&j[temp.x][temp.y]==0)//判断下一个点是否可以走
		{
			if(temp.x==e.x&&temp.y==e.y)
				return temp.step;
			q.push(temp);
			j[temp.x][temp.y]=1;
		}
		}
		q.pop();
	}
	return -1;
}
int main() 
{	
	while(scanf("%d%d",&l,&r)&&r&&l)//rl都不为0，即都为真
	{
	memset(j,0,sizeof(j));	//清空数组
	for(int x=1;x<=l;x++)
	for(int y=1;y<=r;y++)
	{
		scanf(" %c",&map[x][y]);
		if(map[x][y]=='@')
		{
			s.x=x;s.y=y;s.step=0;//记录起点
		}
		if(map[x][y]=='*')
		{
			e.x=x;e.y=y;//记录终点
		}
	}
	printf("%d\n",bfs(s));
	}
	return 0;
}

然而，搜索有一种叫做A* 的贪心策略，可以大大提高搜索速度，放图

可以看出，A* 算法远远快于普通的BFS，推荐一个b站视频
视频链接
我在下方放出C++代码，不懂的地方可以评论区提问。
总感觉和dijkstra算法有点像…

#include<bits/stdc++.h>
using namespace std;

char mp[305][305];//map
int j[305][305];//judge[]判断是否走过并且记录代价
int dir[4][2]= {1,0,-1,0,0,1,0,-1};
int m,n,gox,goy;//用gox，goy记终点坐标
struct node
{
	int x;
	int y;
	int step;//当前代价
	int value;//总代价，即当前代价+预估代价
	friend bool operator <(node a,node b)//重载运算符使优先队列达到自己目的
	{
		return a.value>b.value;
	}
};

priority_queue<node> q ;//优先队列，可以重载node使价值小的排在前面，是竞赛经常使用的容器

int bfs()
{
	while(!q.empty())
	{
		node temp=q.top(),nex;
		//	cout<<temp.x<<' '<<temp.y<<' '<<temp.step<<endl;
		q.pop();
		for(int x=0; x<4; x++)
		{
			nex.step=temp.step+1;
			nex.x=temp.x+dir[x][0];
			nex.y=temp.y+dir[x][1];
			nex.value=abs(gox-nex.x)+abs(goy-nex.y)+nex.step;//总代价=预估代价(曼哈顿距离)+当前代价
			if(nex.x==gox&&nex.y==goy)
				return nex.step;
			if(nex.x>0&&nex.x<=m&&nex.y>0&&nex.y<=n&&(j[nex.x][nex.y]==0||nex.value<j[nex.x][nex.y])
			        &&mp[nex.x][nex.y]!='#')//没走过或者代价更低！A*关键 ，与普通bfs不同的地方
			{
				q.push(nex);
				j[nex.x][nex.y]=nex.value;
			}
		}
	}
	return -1;
}

int main()
{
	//ios::sync_with_stdio(false);
	//cin.tie(0);
	//上面两行加速cin的，可以忽略
	while(cin>>m>>n&&m&&n)//m，n都不为0
	{
		q=priority_queue<node>();//清空优先队列
		memset(j,0,sizeof(j));//数组清0
		for(int x=1; x<=m; x++)
		{
			for(int y=1; y<=n; y++)
			{
				cin>>mp[x][y];
				if(mp[x][y]=='@')//找到起点直接放进去就行了
				{
					q.push({x,y,0});
					j[x][y]=1;
				}
				if(mp[x][y]=='*')
				{
					gox=x;
					goy=y;
				}
			}
		}
		cout<<bfs()<<endl;
	}
	return 0;
}