CSU1046: 追杀

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的内容，但是这和平时的bfs不一样，平时的bfs是一个动但另一个静，但这里是两个都在动，所以选择先动一个，然后动另一个再动第二个的时候就进行对比了。

这题开始的时候先把国王走的不重复时间记下来，然后再让骑士去找，但是发现国王很快就会遇到他原来走过的地方，会影响结果，所以先把骑士的找出来，然后国王再走，同时我们注意到，如果国王到的某个点的时间如果小于骑士到这个点的时间，那么在这个点骑士是不可能追上国王的，所以追上国王的时间大于等于骑士到这个点的时间，而根据题意，它们的时间差应该是2的两倍，这点很重要，不然也是追不到的，实际上就是先走过去然后又走回来要用两步的缘故。

 

#include <iostream>  
#include <cstdio>  
#include <cstdlib>  
#include <algorithm>  
#include <vector>  
#include <map>  
#include <set>  
#include <string>  
#include <cstring>  
#include <list>  
#include <queue>  
#include <stack>  
#include <cmath>    
using namespace std;   
#define Inf 0x7fffffff  
  
struct P  
{  
    int x,y;  
    int time;  
};  
P s,em;  
queue<P> G;  
queue<P> GG;  
int dist[8][2] = {2,1,2,-1,1,2,1,-2,-2,1,-2,-1,-1,2,-1,-2};  
int dx,dy;  
int maps[10][10];  //记录骑士走到每个点耗费的时间
int emper[10][10];  //记录国王走到每个点耗费的时间
int minx = Inf;  
void reinit()  
{  
    while(!G.empty()) G.pop();  
    while(!GG.empty()) GG.pop();  
    memset(maps,-1,sizeof(maps));  
    memset(emper,-1,sizeof(emper));  
    minx = Inf;  
}  
bool is(int x,int y)  //判断是否越界
{  
    if(x<0 ||y<0 ||x>8 ||y>7) return false;  
    return true;  
}  
void bfs()  
{  
    GG.push(em);  
    dx = 1;  
    dy = 1;  
    emper[em.y][em.x]=0;  
    while(!GG.empty())  
    {  
        P a = GG.front();GG.pop();  
        P te;  
        if(a.time>=maps[a.y][a.x] && (a.time-maps[a.y][a.x])%2==0) //判断是否碰到了 
            {minx = a.time;return ;}  
  //因为不同的碰到边界反射的情况不一样，所以对应的next的x，y不一样，要分类。
        if(a.x == 0 && a.y == 0) ！  
        {     
            if(dx == -1 && dy ==-1)  
            dx = 1,dy =1;  
            else if(dx == -1 && dy ==1)  
                dx = -dx;  
            else if(dx == 1&&dy == 1)  
                ;  
            else dy =-dy;  
  
        }  
        else if(a.x==8 && a.y == 0 )  
        {  
            if(dx == -1 && dy ==-1)  
               dy=-dy;  
            else if(dx == -1 && dy ==1)  
                ;  
            else if(dx == 1&&dy == 1)  
                dx=-dx;  
            else dx=-dx,dy=-dy;  
        }  
  
        else if(a.x == 0 && a.y == 7)  
        {  
            if(dx == -1 && dy ==-1)  
              dx = -dx;  
            else if(dx == -1 && dy ==1)  
                dx=-dx,dy=-dy;  
            else if(dx == 1&&dy == 1)  
                dy=-dy;  
            else;  
        }  
        else if(a.x == 8 &&a.y == 7)   
        {  
            if(dx == -1 && dy ==-1)  
            ;  
            else if(dx == -1 && dy ==1)  
                dy=-dy;  
            else if(dx == 1&&dy == 1)  
                dx=-dx,dy=-dy;  
            else dx=-dx;  
        }  
        else if(a.x == 8 ) dx = -dx;  
        else if(a.x == 0 &&a.time !=0) dx=-dx;  
        else if(a.y == 7) dy=-dy;  
        else if(a.y==0 && a.time !=0) dy=-dy;  
        te.x = a.x + dx;  
        te.y = a.y + dy;  
        te.time = a.time +1;  
        emper[te.y][te.x]= te.time;  
        GG.push(te);  
    }  
}  
void rebfs()  
{  
    G.push(s);  
    maps[s.y][s.x]=0;  
    while(!G.empty())  
    {  
        P b = G.front();  
        G.pop();  
        for(int i=0;i<8;i++)  
        {  
                P te;  
                te.x = b.x + dist[i][0];  
                te.y = b.y + dist[i][1];  
                te.time = b.time+1;  
                if(is(te.x,te.y) && maps[te.y][te.x] == -1)  
                {  
                    maps[te.y][te.x] = te.time;  
                    G.push(te);  
                }  
        }     
    }  
}  
void init()  
{  
    while(scanf("%d%d%d%d",&s.x,&s.y,&em.x,&em.y)!=EOF)  
    {  
        reinit();  
        s.time = 0;  
        em.time = 0;  
        rebfs();  //先进行骑士
        bfs();  //再进行国王
        cout<<minx<<endl;
    }  
    return ;  
}    
int main()  
{  
    init();  
    return 0;  
}