8600 骑士问题
时间限制:1000MS  内存限制:1000K

描述
在一个标准8×8的国际象棋棋盘上，棋盘中有些格子是可能有障碍物的。已知骑士的初始位置和目标位置，你的任务是计算出骑士最少需要多少步可以从初始位置到达目标位置。有障碍物的格子当然不可能到达。

标准的8×8的国际象棋棋盘中每一个格子可以用唯一的编号确定。行用1～8这8个数字依次表示，列用“a”～“h”这8个字母依次表示。例如下图（a）的骑士所在位置（图中有n的格子）的编号为“d4”（注意“d”和“4”之间没有空格）。

我们知道国际象棋中的骑士可以按“L”路线移动（一个方向走2个格子，接着垂直方向走一个格子）。
因此，如图（a）所示的骑士（位于d4），可以到达位置c2，b3，b5，c6，e6，f5，f3和e2（图中有“x”标记的格子）。此外，骑士不能移出棋盘。

骑士可以按照移动规则自由地在棋盘上没有障碍物的格子中移动。图（b）给出了一个骑士移动的例子，也就是输入样例中第一组数据对应的例子。
初始格子用“n”标记，目标格子用“N”标记，有障碍物的格子用“b”标记。一个可行的移动序列在图中用数字标记出来（a1，b3，a5，c6，e5，g4，h2，f1）。总共需要7步才能完成。
事实上，这也是最少的步数了。

输入格式
输入包含1个或多个测试数据。
每一个测试数据的第一行是一个整数b（-1 <= b <= 62），表示棋盘中有障碍物的格子数目。当b＝-1时，输入结束。
第二行含b个不同的障碍物的格子编号，用空格隔开。当b=0时，此行为空行。
第三行是骑士的初始格子和目标格子的编号，也是用空格隔开。初始格子和目标格子是不同的，且都没有障碍物。

输出格式
对于每个数据，输出一行。格式
Board n:m moves
其中n表示数据的序号（从1开始），m表示骑士所用的最小步数。
如果骑士无法到达目标格子，输出
Board n:not reachable
输入样例
10
c1 d1 d5 c2 c3 c4 d2 d3 d4 c5
a1 f1
0

c1 b3
2
b3 c2
a1 b2
-1
输出样例
Board 1:7 moves
Board 2:1 moves
Board 3:not reachable
Hint
这也是一个搜索的题目，非常类似于书上P203~P206页的“布线问题”，解法几乎同，可参考书上此范例。

用一个二维数组board[12][12]来记录棋盘的状况。
为何大小是12*12呢？棋盘大小8*8，为了减少对周围边界的判断，在上下左右四边各加上2行2列做“围墙”（障碍），因此board棋盘的大小12*12。
有如下几个问题或步骤需要解决：
1， 障碍格子：将输入的障碍格子填写到board当中对应格上，设置为-1；
2， 起始格子和结束格子：将起始点start和结束点end，这两个点记录下来，在board中这两个格子设置为0；
3， 围墙：在8*8的棋盘外面，上下左右各加2行2列做围墙，围墙和障碍一样，设置为-1；
4， 除障碍围墙起始结束格子这些格子特殊对待输入之外，其余格子全部初始化为0；
5， 队列初始为空。队列是用来在骑士做 “日字型”对角跳的时候，候选位置放入队列中的一个辅助的数据结构，以便于“广度优先搜索”。
6， 从起点开始，将这个位置所能跳的周围8个位置都检查一下：只要未标记，就标记为前一个位置值加1，并将该位置入队列；
如果不能标记（比如障碍或围墙等），就跳过，继续检查下一个位置，一共八个骑士所能跳的位置。
7， 取出队列首个位置结点，又继续检查这个结点周围的8个位置，类同上一步，直到找到对终点标记位置。
8， 最后，输出终点所标记的数值（正数），就是骑士所需的最少移动步数，若为0表示终点无法标记到，输出：“not reachable”这样的信息。

1–5为初始化步骤，在标记之前就应该做好棋盘和相关辅助数据结构的初始化；
6–8为标记过程。

代码如下：

#include”stdio.h”
#define MAXQSIZE 10000
#define OK 1
————————————————-

#define ERROR 0
#define Status int

int movx[8] = {1,2, 2, 1,-1,-2,-2,-1};
int movy[8] = {2,1,-1,-2,-2,-1, 1, 2};
int blockx[8] = {0,1,1, 0, 0,-1,-1,0};
int blocky[8] = {1,0,0,-1,-1, 0, 0,1}; 
int chess[12][12];
int stax,stay,endx,endy;
int num = 0;

typedef struct {
 int x,y;
}QElemType;

typedef struct
{
   QElemType base[10000]; // 初始化的动态分配存储空间
   int front; // 头指针,若队列不空,指向队列头元素
   int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置
 }SqQueue;

SqQueue Q;

Status InitQueue(SqQueue &Q)  
{
Q.front=Q.rear=0;
return OK; 
}

Status EnQueue(SqQueue &Q,int i,int j) 
{
if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;
Q.base[Q.rear].x=i;
Q.base[Q.rear].y=j;
Q.rear=(Q.rear+1)%MAXQSIZE;
return OK; 
}

Status DeQueue(SqQueue &Q, int &i,int &j)
{ 
if(Q.front==Q.rear)return ERROR;
i=Q.base[Q.front].x;
j=Q.base[Q.front].y;
Q.front=(Q.front+1)%MAXQSIZE;
return OK; 
}

Status Clear(SqQueue &Q){
 Q.rear=Q.front;
 Q.base[Q.front].x=Q.base[Q.front].y=0;
 return OK;
}

void stone(char a[3]){
 chess[a[1] – 47][a[0] – 95] = -1;
}

void move(int x,int y){
 int i,xi,yi;
 EnQueue(Q,x,y);
 while(DeQueue(Q,x,y)){
  for(i=0;i < 8;i++){
   xi=x+movx[i];
   yi=y+movy[i];
   if(chess[xi][yi]==0 && chess[x + blockx[i]][y + blocky[i]] != -1){
    chess[xi][yi]=chess[x][y]+1;
    EnQueue(Q,xi,yi);
   }
   if(xi==endx&&yi==endy){Clear(Q);break;}
  }
 }
}

int main(){
 int n,k,i,j;
 char ch[3];
 char key;
  for(i=0;i<2;i++)
   for(j=0;j<12;j++)
    chess[i][j]=-1;
  for(i=2;i<12;i++)
   for(j=0;j<2;j++)
   chess[i][j]=-1;
  for(i=2;i<12;i++)
   for(j=10;j<12;j++)
   chess[i][j]=-1;
  for(i=10;i<12;i++)
   for(j=2;j<10;j++)
   chess[i][j]=-1;
 scanf(“%d”,&n);
    while(n != -1){
     num ++;   
  InitQueue(Q);
  for(i=2;i<10;i++)
   for(j=2;j<10;j++)
   chess[i][j] = 0;
  for(k = 0; k < n; k++){
   scanf(“%s”,ch);
   stone(ch);
  }
  scanf(“%s”,ch);
  stay = ch[0] – 95;
  stax = ch[1] – 47;
     scanf(“%s”,ch);
  endy = ch[0] – 95;
  endx = ch[1] – 47;
  move(stax,stay);
  if(chess[endx][endy] != 0)
   printf(“Board %d:%d moves\n”,num,chess[endx][endy]);
  else printf(“Board %d:not reachable\n”,num);

  scanf(“%d”,&n);

   
 }
 return 1;
}