POJ 2243 Knight Moves A*
题意：
象棋中马从一个格子到另一个格子最少需要多少步
思路：
简单BFS，主要用此题练习了A*算法
A*算法，原理同BFS，只是通过启发式函数（代码中的f，为起点到该点的代价g和该点到终点的股价h的和）来进行BFS的剪枝。
源码：
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
#define ABS(a) (((a)>0)?(a):(-(a)))///abs，注意每个a都需要括号，总的还需要一个括号
int vis[10][10];
char str[10];
int dx[] = {-1,-2,-2,-1,1,2,2,1};///方向
int dy[] = {-2,-1,1,2,2,1,-1,-2};
int x1,x2,y1,y2,ans;///初始坐标和目的坐标，答案
struct D
{
int x,y,step;
int f,g,h;
D(){step = 0;}
D(int _x,int _y,int _step,int _f,int _g,int _h){x = _x,y = _y,step = _step;f = _f;g = _g;h = _h;}
bool operator < (const D &a)const{return f > a.f;}///在优先队列，符号需要相反，比如小的在前需要f>a.f
};///fgh分别表示启发式函数和，从初始点到此点代价，从此点到终点股价
priority_queue<D> que;///优先队列实现
int haminton(int x,int y)///曼哈顿距离
{
// printf("x = %d,y = %d,x2 = %d,y2 = %d\n",x,y,x2,y2);
int ans = ABS(x - x2) + ABS(y - y2);
// printf("ans = %d\n\n",ans);
return ans * 10;
}
bool valid(int x,int y)
{
if(x < 0 || x > 7)
return false;
if(y < 0 || y > 7)
return false;
return true;
}
int main()
{
while(gets(str) != NULL){
x1 = str[0] - 'a';
y1 = str[1] - '1';
x2 = str[3] - 'a';
y2 = str[4] - '1';
while(!que.empty())
que.pop();
if(x1 == x2 && y1 == y2){
ans = 0;
}
else{
memset(vis, 0, sizeof(vis));
vis[x1][y1] = 1;
D temp = D(x1,y1,0,haminton(x1,y1),0,haminton(x1,y1));
que.push(temp);
ans = -1;
while(!que.empty()){
temp = que.top();
que.pop();
int x = temp.x;
int y = temp.y;
int step = temp.step;
int g = temp.g;
int h = temp.h;
// printf("x = %d,y = %d,step = %d,f = %d,g = %d,h = %d\n",x,y,step,temp.f,g,h);
if(x == x2 && y == y2){
ans = step;
break;
}
for(int i=0; i<8; i++){
int tx = x + dx[i];
int ty = y + dy[i];
int tstep = step + 1;
if(!valid(tx,ty) || vis[tx][ty] == 1)
continue;
vis[tx][ty] = 1;
int tg = 23 + g;
int th = haminton(tx,ty);
temp = D(tx,ty,tstep,tg+th,tg,th);
que.push(temp);
}
}
}
printf("To get from %c%c to %c%c takes %d knight moves.\n",str[0],str[1],str[3],str[4],ans);
}
return 0;
}