CSU 1046 追杀

Description

在一个8行9列的国际象棋棋盘上，有一名骑士在追杀对方的国王。该骑士每秒跨越一个2*3的区域，如下图所示。

而对方的国王慌忙落逃，他先沿着右下斜线方向一直跑，遇到边界以后会沿着光线反射方向继续跑（遇到死角则原路返回），他每秒只跑一格。

给出骑士和国王的初始位置，求最快在多少秒的时候骑士能追杀掉对方的国王。骑士和国王每一秒都必须要有行动，而不能原地等待。

Input

有多组测试数据。对于每组测试数据，输入只有一行：nx,ny,kx,ky，前2个表示骑士的初始坐标，后2个表示国王的初始坐标，以左上角的格子为(0,0),向右为x轴正方向，向下为y轴正方向。(0<=nx,kx<=8,0<=ny,ky<=7)

Output

对于每组测试数据，仅输出一个整数，即骑士追杀到国王的最快时刻。初始位置的时刻为0。追杀到的时刻是指骑士和国王处在同一格的时刻。

Sample Input

0 7 0 0

Sample Output

3
和正常的bfs不同，一个静点，一个动点，这个两个都是动点，求交汇处所需的最小步数，一个要注意移动的规则，还有就是重复走过的点，避免死循环。

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;
#define lowbit(x) (x&(-x))
#define max(x,y) (x>y?x:y)
#define min(x,y) (x<y?x:y)
#define MAX 100000000000000000
#define MOD 1000000007
#define pi acos(-1.0)
#define ei exp(1)
#define PI 3.141592653589793238462
#define ios() ios::sync_with_stdio(false)
#define INF 1044266558
#define mem(a) (memset(a,0,sizeof(a)))
typedef long long ll;
int dirp[][]={{,},{-,},{-,},{-,-},{-,-},{,-},{,-},{,}};
int dirk[][]={{,-},{-,-},{-,},{,}};
int xp,yp,xk,yk;
int turn[][][][][];
struct Node
{
    int px;
    int py;
    int kx;
    int ky;
    int step;
}ans,pos;
Node trans(Node a,int x)
{
    int x1,x2,y1,y2,k;
    int nx1,nx2,ny1,ny2,nk;
    x1=a.px;y1=a.py;x2=a.kx;y2=a.ky;k=a.step;
    nx1=x1+dirp[x][];
    ny1=y1+dirp[x][];
    if(nx1< || ny1< || nx1> || ny1>) {a.step=-;return a;}
    if(x2== && y2== && k==) nx2=,ny2=,nk=;
    else if(x2== && y2== && k==) nx2=,ny2=,nk=;
    else if(x2== && y2== && k==) nx2=,ny2=,nk=;
    else if(x2== && y2== && k==) nx2=,ny2=,nk=;
    else if(x2== && (k== || k==))
    {
        nx2=;
        if(k==) ny2=y2-,nk=;
        else ny2=y2+,nk=;
    }
    else if(x2== && (k== || k==))
    {
        nx2=;
        if(k==) ny2=y2-,nk=;
        else ny2=y2+,nk=;
    }
    else if(y2== && (k== || k==))
    {
        ny2=;
        if(k==) nx2=x2+,nk=;
        else nx2=x2-,nk=;
    }
    else if(y2== && (k== || k==))
    {
        ny2=;
        if(k==) nx2=x2-,nk=;
        else nx2=x2+,nk=;
    }
    else nx2=x2+dirk[k][],ny2=y2+dirk[k][],nk=k;
    if(turn[nx1][ny1][nx2][ny2][nk]!=-) {a.step=-;return a;}//说明此情况已出现过无解，死循环。
    turn[nx1][ny1][nx2][ny2][nk]=turn[x1][y1][x2][y2][k]+;
    a.px=nx1;a.py=ny1;a.kx=nx2;a.ky=ny2;a.step=nk;
    return a;
}
void bfs(int x1,int y1,int x2,int y2)
{
    queue<Node>q;
    int cnt=;
    memset(turn,-,sizeof(turn));
    ans.px=x1;ans.py=y1;ans.kx=x2;ans.ky=y2;ans.step=;
    turn[x1][y1][x2][y2][]=;
    q.push(ans);
    while(!q.empty())
    {
        pos=q.front();
        q.pop();
        if(pos.px==pos.kx && pos.py==pos.ky)
        {
            cnt=turn[pos.px][pos.py][pos.kx][pos.ky][pos.step];
            break;
        }
        for(int i=;i<;i++)
        {
            ans=trans(pos,i);
            if(ans.step>=) q.push(ans);
        }
    }
    printf("%d\n",cnt);
}
int main()
{
    while(scanf("%d%d%d%d",&xp,&yp,&xk,&yk)!=EOF)
    {
        bfs(xp,yp,xk,yk);
    }
    return ;
}