棋

/*BFS学习*/
#include <algorithm>
#include <iostream>
#include <cstring>

using namespace std;

char chx,chy;
int sx,sy,tx,ty;
int head,tail,ans;
int fx[9]={0,1,-1,1,-1,2,-2,2,-2},
    fy[9]={0,2,2,-2,-2,1,-1,-1,1};
bool go,map[10][10];

struct node_ans_que
{
    int x,y,step;
}que[1000*1000];

struct node_from_que
{
    int x,y;
}q[1000*1000];

int main()
{
    cin>>chx>>sy;  sx=chx-96;
    cin>>chy>>ty;  tx=chy-96;
    map[sx][sy]=1;
    que[tail].x=sx,que[tail].y=sy,que[tail++].step=0;
    int step=0;
    q[step].x=sx,q[step].y=sy;
    while(head<tail)
    {
        int x=que[head].x,y=que[head].y;step=que[head].step;
        
        for(int i=1;i<=8;i++)
        {
            int xx=x+fx[i];
            int yy=y+fy[i];
            if(xx==tx&&yy==ty&&!map[tx][ty])
            {
                go=1;
                ans=step+1;
            }
            if(go)    break;
            if(xx>0&&xx<9&&yy>0&&yy<9)
                if(!map[xx][yy])
                {
                    map[xx][yy]=1;
                    que[tail].x=xx;
                    que[tail].y=yy;
                    que[tail++].step=step+1;
                    q[step].x=x,q[step].y=y;
                }
        }
        if(go)    break;
        head++;
    }
    q[ans].x=tx,q[ans].y=ty;
    for(int i=0;i<=ans;i++)
    {
        char ch=q[i].x+96;
        cout<<ch<<q[i].y<<" ";
    }
    cout<<endl;
    cout<<"To get from "<<chx<<sy<<" to "<<chy<<ty<<" take "<<ans<<" knight moves."<<endl;
    return 0;
}

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

struct QueueNodeType {
    int x,y,step;
};

const int dx[9]={0,-2,-1,1,2,2,1,-1,-2};
const int dy[9]={0,1,2,2,1,-1,-2,-2,-1};

int sx,sy,ex,ey,ans,from[10][10][2];

bool map[10][10];

queue<struct QueueNodeType>que;

struct QueueNodeType node(int x,int y,int step)
{
    struct QueueNodeType nod;
    nod.x=x,nod.y=y,nod.step=step;
    return nod;
}

void path(int x,int y)
{
    if(from[x][y][0]&&from[x][y][1]) path(from[x][y][0],from[x][y][1]);
    cout<<char(x+96)<<' '<<y<<endl;
    return ;
}

int main()
{
    char ch;
    int num;
    cin>>ch>>num;
    sx=ch-'a'+1,sy=num;
    cin>>ch>>num;
    ex=ch-'a'+1,ey=num;
    que.push(node(sx,sy,0));
    map[sx][sy]=true;
    while(!que.empty())
    {
        bool if_break=false;
        struct QueueNodeType pos=que.front();
        for(int i=1;i<=8;i++)
        {
            if(pos.x+dx[i]>0&&pos.x+dx[i]<=8&&pos.y+dy[i]>0&&pos.y+dy[i]<=8)
            {
                if(pos.x+dx[i]==ex&&pos.y+dy[i]==ey)
                {
                    from[pos.x+dx[i]][pos.y+dy[i]][0]=pos.x;
                    from[pos.x+dx[i]][pos.y+dy[i]][1]=pos.y;
                    ans=pos.step+1;
                    if_break=true;
                    break;
                }
                if(!map[pos.x+dx[i]][pos.y+dy[i]])
                {
                    map[pos.x+dx[i]][pos.y+dy[i]]=true;
                    from[pos.x+dx[i]][pos.y+dy[i]][0]=pos.x;
                    from[pos.x+dx[i]][pos.y+dy[i]][1]=pos.y;
                    que.push(node(pos.x+dx[i],pos.y+dy[i],pos.step+1));
                }
            }
        }
        if(if_break) break;
        que.pop();
    }
    cout<<"To get from "<<char(sx+'a'-1)<<sy<<" to "<<char(ex+'a'-1)<<ey<<"takes "<<ans<<" knight moves."<<endl;
    path(ex,ey);
    return 0;
}