【搜索】下棋

下棋

Time Limit: 6000/3000 MS (Java/Others)
Memory Limit: 65536/65536 K (Java/Others)

Problem Description

N∗M的棋盘上有一个受伤的国王与一个要去救援国王的骑士，他们每个单位时间必须同时移动一次寻找对方。
如下图所示，黑色的图例表示国王（右）或骑士（左）当前所在的位置，那么灰色的位置表示在一次移动中他们可能到达的位置。国王伤势严重，因此他必须在K个单位时间内得到骑士的救援，否则会挂掉。
问国王是否可以在K个单位时间内获得救援，如果可以，最短需要花多少个单位时间。

Input

第一行包含一个整数T,（1≤T≤50）代表测试数据的组数，接下来T组测试数据。
每组测试数据第一行包含三个整数N,M,K, 且2≤N,M≤1000, 1≤K≤200。
第二行两个整数Xking,Yking，对应国王所在方格的坐标。
第三行两个整数Xknight,Yknight，对应骑士所在方格的坐标。其中1≤Xking,Xknight≤N,1≤Yking,Yknight≤M,保证骑士与国王一开始不在同一个方格内且他们都可以移动。

Output

对于每组测试数据，输出两行：
第一行输出：”Case #i:”。i代表第i组测试数据。
第二行输出测试数据的结果，如果国王可以得到救援，则输出最快需要花多少个单位时间。否则，输出“OH,NO!”。

Sample Input

2
3 2 1
1 1
3 1
3 3 1
1 1
1 2 

Sample Output

Case #1:
1
Case #2:
OH,NO!

题解：

可以对国王和骑士各自进行一遍bfs，扫出到达每个点的最小时间，然后枚举每一个点，进行如下讨论：
1> 骑士到达时间 == 国王到达时间，ans = min(ans,时间);
2> 骑士到达时间 < 国王到达时间，我们知道，骑士走一步，它的坐标的加和的奇偶性一定会发生改变(±3)，而国王走一步，它的奇偶性可变也可不变。
所以此时我们需要判断他们的奇偶性，如果一样，ans = min(ans,国王时间)，如果不一样，ans = min(ans,国王时间 + 1)。
3> 骑士到达时间 > 国王到达时间，此时如果骑士到达的时间 > 1，则ans = min(ans,国王时间)。

Code：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#define N 1100
using namespace std;
int T,n,m,k,ans,qx[2*N*N],qy[2*N*N],f[2][N][N];
int X[2][10] = {{-1,-2,-1,-2,1,2,1,2},{-1,-1,-1,1,1,1,0,0}};
int Y[2][10] = {{-2,-1,2,1,-2,-1,2,1},{-1,0,1,-1,0,1,-1,1}};
int in(){
    int x = 0; char ch = getchar();
    while (ch < '0' || ch > '9') ch = getchar();
    while (ch >= '0' && ch <= '9')
        x = x * 10 + ch - '0',ch = getchar();
    return x;
}
void bfs(int x,int y,int p){
    int h=0,t=1; qx[h] = x,qy[h] = y;
    f[p][x][y]=0;
    while (h < t){
        int xx = qx[h],yy = qy[h];
        if (f[p][xx][yy] >= k) break;
        for (int i = 0; i < 8; i++){
            int xxx=xx + X[p][i],yyy=yy + Y[p][i];
            if (xxx >=1 && xxx <=n && yyy >=1 && yyy <=m && f[p][xxx][yyy]>1000000){
                qx[t] = xxx,qy[t] = yyy;
                f[p][qx[t]][qy[t]]=f[p][qx[h]][qy[h]]+1;
                t++;
            }
        }
        h++;
    }
}
void work(){
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++){
            if (f[0][i][j] > k || f[1][i][j] > k) continue;
            if (f[0][i][j] == f[1][i][j]) ans = min(ans,f[0][i][j]);
            else if (f[0][i][j] <= f[1][i][j]) ans = min(ans,f[1][i][j] + ((f[0][i][j]&1)^(f[1][i][j]&1)));
            else if (f[0][i][j] > 1) ans = min(ans,f[0][i][j]);
        }
}
int main(){
    T = in();
    for (int _ = 1; _ <= T; _++){
        n = in(),m = in(),k = in();
        int wx = in(),wy = in(),mx = in(), my = in();
        memset(f,0x7f,sizeof(f));
        bfs(mx,my,0); bfs(wx,wy,1);
        ans = 0x7fffffff; work();
        printf("Case #%d:\n",_);
        if (ans > k) printf("OH,NO!\n");
        else printf("%d\n",ans);
    }
    return 0;
}