uva 439 Knight Moves

很简单的骑士周游问题，简单的BFS

一个骑士在当前位置的话可以像8个方向走，至于骑士是怎么走的可以百度一下

记录起点和终点的行列并算出它的标号（整个棋盘是8*8的，按行优先去编号从1到64，所以每个格子都会有一个唯一的编号）

走了8个方向记录下每个方向的编号，每得到一个编号就判断和终点编号是否相同，是的话就已经走到了，跳出,否则的话这个格子入队

另外就是记录步数，就是代码中的k

另外要注意判断起点和终点相同的情况，都是输出0

 

#include <stdio.h>

#include <string.h>

#include <queue>

#define MAX 70

using namespace std;

bool vis[70];

int START,END;

char s[10];

struct node

{int num,r,c,k;};

queue<struct node> q;



void BFS()

{

    int i,k,R[9],C[9];

    struct node tmp;



    while(!q.empty()) q.pop();

    tmp.num=START; tmp.k=0;

    tmp.r = ((START%8)==0) ? (START/8) : (START/8+1) ;

    tmp.c = ((START%8)==0) ? 8 : START%8 ;

    q.push(tmp);   //初始化把起点入队

    if(tmp.num==END) q.pop();

    while(!q.empty())  //这个判断可以省去

    {

        tmp=q.front(); q.pop(); //出队一个元素

        k=tmp.k;

        R[1]=tmp.r-2;  C[1]=tmp.c-1;   

        R[2]=tmp.r-2;  C[2]=tmp.c+1;

        R[3]=tmp.r-1;  C[3]=tmp.c+2;

        R[4]=tmp.r+1;  C[4]=tmp.c+2;

        R[5]=tmp.r+2;  C[5]=tmp.c+1;

        R[6]=tmp.r+2;  C[6]=tmp.c-1;

        R[7]=tmp.r+1;  C[7]=tmp.c-2;

        R[8]=tmp.r-1;  C[8]=tmp.c-2;



        for(i=1; i<=8; i++)

        {

            if(R[i]>=1 && R[i]<=8 && C[i]>=1 && C[i]<=8)

            {

                tmp.r=R[i]; tmp.c=C[i]; tmp.k=k+1;

                tmp.num=(tmp.r-1)*8+tmp.c;

                q.push(tmp);   //入队

                if(tmp.num==END)  break;

            }

        }



        if(i<=8)  break;



    }

    printf("To get from %c%c to %c%c takes %d knight moves.\n",s[0],s[1],s[3],s[4],tmp.k);



    return ;



}

int main()

{

    int r,c;

    while(gets(s))

    {

        c=s[0]-'a'+1;  r=s[1]-'0';

        START=8*(r-1)+c;

        c=s[3]-'a'+1;  r=s[4]-'0';

        END=8*(r-1)+c;



        BFS();

    }

    return 0;

}