Description

小 B 最近迷上了華容道，可是他總是要花很長的時間才能完成一次。於是，他想到用程式設計來完成華容道：給定一種局面，華容道是否根本就無法完成，如果能完成，最少需要多少時間。

小 B 玩的華容道與經典的華容道遊戲略有不同，遊戲規則是這樣的：

1. 在一個 n*m 棋盤上有 n*m 個格子，其中有且只有一個格子是空白的，其餘 n*m-1 個格子上每個格子上有一個棋子，每個棋子的大小都是 1*1 的；

2. 有些棋子是固定的，有些棋子則是可以移動的；

3. 任何與空白的格子相鄰（有公共的邊）的格子上的棋子都可以移動到空白格子上。

遊戲的目的是把某個指定位置可以活動的棋子移動到目標位置。

給定一個棋盤，遊戲可以玩 q 次，當然，每次棋盤上固定的格子是不會變的，但是棋盤上空白的格子的初始位置、指定的可移動的棋子的初始位置和目標位置卻可能不同。第 i 次玩的時候，空白的格子在第 EXi行第 EYi列，指定的可移動棋子的初始位置為第 SXi行第 SYi列，目標位置為第 TXi行第 TYi列。

假設小 B 每秒鐘能進行一次移動棋子的操作，而其他操作的時間都可以忽略不計。請

你告訴小 B 每一次遊戲所需要的最少時間，或者告訴他不可能完成遊戲。

Input

第一行有 3 個整數，每兩個整數之間用一個空格隔開，依次表示 n、m 和 q；
接下來的 n 行描述一個 n*m 的棋盤，每行有 m 個整數，每兩個整數之間用一個空格隔開，每個整數描述棋盤上一個格子的狀態，0 表示該格子上的棋子是固定的，1 表示該格子上的棋子可以移動或者該格子是空白的。

Output

輸出有 q 行，每行包含 1 個整數，表示每次遊戲所需要的最少時間，如果某次遊戲無法完成目標則輸出−1。

Sample Input

Sample Output

HINT

【輸入輸出樣例說明】

棋盤上劃叉的格子是固定的，紅色格子是目標位置，圓圈表示棋子，其中綠色圓圈表示目標棋子。

1.第一次遊戲，空白格子的初始位置是 (3, 2)（圖中空白所示），遊戲的目標是將初始位置在(1, 2)上的棋子（圖中綠色圓圈所代表的棋子）移動到目標位置(2, 2)（圖中紅色的格子）上。

2.第二次遊戲，空白格子的初始位置是（1, 2）（圖中空白所示），遊戲的目標是將初始位置在（2, 2）上的棋子（圖中綠色圓圈所示）移動到目標位置 (3, 2)上。

要將指定塊移入目標位置，必須先將空白塊移入目標位置，空白塊要移動到目標位置，必然是從位置（2，2）上與當前圖中目標位置上的棋子交換位置，之後能與空白塊交換位置的只有當前圖中目標位置上的那個棋子，因此目標棋子永遠無法走到它的目標位置，遊戲無法完成。

【資料範圍】

對於 30%的資料，1 ≤ n, m ≤ 10，q = 1；

對於 60%的資料，1 ≤ n, m ≤ 30，q ≤ 10；

對於 100%的資料，1 ≤ n, m ≤ 30，q ≤ 500。

這道題真是把我打噁心了，重寫了三四遍，一開始沒太理解，後來看了許多題解，終歸是大致清楚了，60分的做法就是暴力BFS，但是為什麼只有60分，又該如何去優化。首先q次詢問，地圖是固定的，所以想到建圖。在建圖中，各節點為狀態！！，邊權即為狀態轉移所需的步數。空白格與指定塊之間有四種狀態，上下左右，可以用0，1，2，3來表示不同方向，所以考慮用三維陣列來儲存，最後在目標塊四個方向的dis中尋找最小值，若為INF則無法到達，輸出-1，否則輸出最小值。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#define INF 0x7fffffff
using namespace std;
const int Maxt = 32;
const int Maxn = 3610;
const int Maxm = Maxn * 5;
int n,m,p;
bool mp[Maxt][Maxt],check[Maxn];
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};
int predis[Maxt][Maxt],dis[Maxn];
int head[Maxn],to[Maxm],nxt[Maxm],val[Maxm],tot;
void add(int x,int y,int z)
{
    val[++tot]=z;
    to[tot]=y;
    nxt[tot]=head[x];
    head[x]=tot;
}
queue<int>que,qx,qy;
int get_id(int x,int y) 
{
    y--; 
    return (x-1)*m+y<<2;
}
void bfs(int ex,int ey,int px,int py,int d) 
{
    int cx,cy,nx,ny; 
    memset(predis,-1,sizeof(predis));
    predis[px][py]=1;
    predis[ex][ey]=0;
    qx.push(ex),qy.push(ey);
    while(!qx.empty()) 
    {
        int x=qx.front(),y=qy.front();
        qx.pop(),qy.pop();
        for(int i=0; i<4; i++) 
        {
            int tx=x+dx[i],ty=y+dy[i];
            if(mp[tx][ty] && predis[tx][ty]==-1) 
            {
                predis[tx][ty]=predis[x][y]+1;
                qx.push(tx),qy.push(ty);
            }
        }
    }

    if(d==8) 
        return;
    int tmp=get_id(px,py);
    for(int i=0; i<4; ++i)
    {
        int x=px+dx[i],y=py+dy[i];
        if(predis[x][y]>0)
            add(tmp+d,tmp+i,predis[x][y]);

    }
    add(tmp+d,get_id(ex,ey)+(d+2)%4,1);
}

void spfa(int sx,int sy) 
{
    int tmp;
    memset(dis,-1,sizeof(dis));
    for(int i=0; i<4; i++)
    {
        int x=sx+dx[i],y=sy+dy[i];
        if(predis[x][y]!=-1) 
        {
            tmp=get_id(sx,sy)+i;
            dis[tmp]=predis[x][y];
            que.push(tmp);
            check[tmp]=1;
        }
    }
    int k;
    while(!que.empty()) 
    {
        k=que.front();
        que.pop();
        check[k]=0;
        for(int i=head[k];i;i=nxt[i])
        {
            int y=to[i];
            if(dis[y]==-1 || dis[y]>dis[k]+val[i]) 
            {
                dis[y]=dis[k]+val[i];
                if(check[y]==0) 
                {
                    check[y]=1;
                    que.push(y);
                }
            }
        }
    }
} 

int main()
{
    scanf("%d%d%d",&n,&m,&p);
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            scanf("%d",&mp[i][j]);
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++)
            if(mp[i][j]) 
            {
                for(int k=0;k<4;k++)
                {
                    if(mp[i+dx[k]][j+dy[k]]==1)
                        bfs(i+dx[k],j+dy[k],i,j,k);
                }
            }
    int ex,ey,sx,sy,tx,ty,ans;
    while(p--) 
    {
        scanf("%d%d%d%d%d%d",&ex,&ey,&sx,&sy,&tx,&ty);
        if(sx==tx && sy==ty)
        {
            printf("0\n");
            continue;
        }
        if(mp[tx][ty]==0)
        {
            printf("-1\n");
            continue;
        }
        bfs(ex,ey,sx,sy,8); 
        spfa(sx,sy);
        ans=INF;
        int tmp=get_id(tx,ty);
        for(int i=0; i<4; i++)
            if(dis[tmp+i]!=-1)  
                ans=min(ans,dis[tmp+i]);
        if(ans==INF)
            ans=-1;
        printf("%d\n",ans); 
    }
    return 0;
}