POJ---2243 Knight Moves 使用A*算法的广度优先搜索

题目链接：http://poj.org/problem?id=2243

启发式搜索：启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。

估价函数：从当前节点移动到目标节点的预估费用；这个估计就是启发式的。在寻路问题和迷宫问题中，我们通常用曼哈顿（manhattan）估价函数（下文有介绍）预估费用。

A*算法与BFS：可以这样说，BFS是A*算法的一个特例。对于一个BFS算法，从当前节点扩展出来的每一个节点（如果没有被访问过的话）都要放进队列进行进一步扩展。也就是说BFS的估计函数h永远等于0，没有一点启发式的信息，可以认为BFS是“最烂的”A*算法。

选取最小估价：如果学过数据结构的话，应该可以知道，对于每次都要选取最小估价的节点，应该用到最小优先级队列（也叫最小二叉堆）。在C++的STL里有现成的数据结构priority_queue，可以直接使用。当然不要忘了重载自定义节点的比较操作符。

A*算法的特点：A*算法在理论上是时间最优的，但是也有缺点：它的空间增长是指数级别的。

启发函数：f=g+h;其中g是起点到当前结点的直线距离，h是当前结点到目的结点的某种度量函数，在本题中采用曼哈顿距离。

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <queue>
#include <cstring>
using namespace std;
struct node{
	int x,y,step;
	int f,g,h;
	bool operator<(const node & n)const { //优先队列，需要重载操作符 
		return step>n.step;
	}
	
}k;
int endx,endy;
int Heuristic(const node &a){                  //manhattan估价函数
	return (abs(a.x-endx)+abs(a.y-endy))*10;
}
bool isbond(const node &a){                  //判断是否是边界 
	if(a.x<0||a.y>=8||a.x>=8||a.y<0)return 1;
	return 0;
}
bool visit[10][10];
int dir[8][2]={{-2,-1},{-2,1},{2,-1},{2,1},{-1,-2},{-1,2},{1,-2},{1,2}};
priority_queue<node> Q;             //8个方向 
int bfs()
{
	while(!Q.empty())Q.pop();
	Q.push(k);
	node p,q;
	while(!Q.empty())
	{
		p=Q.top();
		Q.pop();
		if(p.x==endx&&p.y==endy){
			return p.step;
		}
		visit[p.x][p.y]=1;
		for(int i=0;i<8;i++)
		{
			q.x=p.x+dir[i][0];
			q.y=p.y+dir[i][1];
			if(visit[q.x][q.y])continue;
			if(isbond(q))continue;
			q.g=p.g+23;
			q.h=Heuristic(q);
			q.step=p.step+1;
			Q.push(q);
		}
	}
	
}
int main()
{
	string a,b;
	while(cin>>a>>b)
	{
		k.x=a[0]-'a';
		k.y=a[1]-'1';
		endx=b[0]-'a';
		endy=b[1]-'1';
		k.step=k.g=0;
		k.h=Heuristic(k);
		k.f=k.g+k.h;
		memset(visit,0,sizeof(visit));
		cout<<"To get from "<<a<<" to "<<b<<" takes ";  
        cout<<bfs()<<" knight moves."<<endl;  
	}
	return 0;
}