[Noip2013]华容道

题目描述

小 B 最近迷上了华容道，可是他总是要花很长的时间才能完成一次。于是，他想到用编程来完成华容道：给定一种局面，华容道是否根本就无法完成，如果能完成，最少需要多少时间。

小 B 玩的华容道与经典的华容道游戏略有不同，游戏规则是这样的：

1.在一个 n∗mn*mn∗m 棋盘上有 n∗mn*mn∗m 个格子，其中有且只有一个格子是空白的，其余 n∗m−1n*m-1n∗m−1 个格子上每个格子上有一个棋子，每个棋子的大小都是 1∗11*11∗1 的；

2.有些棋子是固定的，有些棋子则是可以移动的；

3.任何与空白的格子相邻（有公共的边）的格子上的棋子都可以移动到空白格子上。游戏的目的是把某个指定位置可以活动的棋子移动到目标位置。

给定一个棋盘，游戏可以玩 qqq 次，当然，每次棋盘上固定的格子是不会变的，但是棋盘上空白的格子的初始位置、指定的可移动的棋子的初始位置和目标位置却可能不同。第 iii 次玩的时候，空白的格子在第 EXiEX_iEX​i​​ 行第 EYiEY_iEY​i​​ 列，指定的可移动棋子的初始位置为第 SXiSX_iSX​i​​ 行第 SYiSY_iSY​i​​ 列，目标位置为第 TXiTX_iTX​i​​ 行第 TYiTY_iTY​i​​ 列。

假设小 B 每秒钟能进行一次移动棋子的操作，而其他操作的时间都可以忽略不计。请你告诉小 B 每一次游戏所需要的最少时间，或者告诉他不可能完成游戏。

输入格式

第一行有 333 个整数，每两个整数之间用一个空格隔开，依次表示 nnn、mmm 和 qqq；

接下来的 nnn 行描述一个 n∗mn*mn∗m 的棋盘，每行有 mmm 个整数，每两个整数之间用一个空格隔开，每个整数描述棋盘上一个格子的状态，000 表示该格子上的棋子是固定的，111 表示该格子上的棋子可以移动或者该格子是空白的。

接下来的 qqq 行，每行包含 666 个整数依次是 EXiEX_iEX​i​​、EYiEY_iEY​i​​、SXiSX_iSX​i​​、SYiSY_iSY​i​​、TXiTX_iTX​i​​、TYiTY_iTY​i​​，每两个整数之间用一个空格隔开，表示每次游戏空白格子的位置，指定棋子的初始位置和目标位置。

输出格式

输出有 qqq 行，每行包含 111 个整数，表示每次游戏所需要的最少时间，如果某次游戏无法完成目标则输出$-1。$

样例

样例输入

3 4 2
0 1 1 1
0 1 1 0
0 1 0 0
3 2 1 2 2 2
1 2 2 2 3 2

样例输出

2
-1

样例说明

棋盘上划叉的格子是固定的，红色格子是目标位置，圆圈表示棋子，其中绿色圆圈表示目标棋子。

第一次游戏，空白格子的初始位置是 (3,2)(3,2)(3,2) （图中空白所示），游戏的目标是将初始位置在 (1,2)(1,2)(1,2) 上的棋子（图中绿色圆圈所代表的棋子）移动到目标位置 (2,2)(2,2)(2,2) （图中红色的格子）上。

移动过程如下：

第二次游戏，空白格子的初始位置是 (1,2)(1,2)(1,2) （图中空白所示），游戏的目标是将初始位置在 (2,2)(2,2)(2,2) 上的棋子（图中绿色圆圈所示）移动到目标位置 (3,2)(3,2)(3,2) 上。

要将指定块移入目标位置，必须先将空白块移入目标位置，空白块要移动到目标位置，必然是从位置 (2,2)(2,2)(2,2) 上与当前图中目标位置上的棋子交换位置，之后能与空白块交换位置的只有当前图中目标位置上的那个棋子，因此目标棋子永远无法走到它的目标位置，游戏无法完成。

数据范围与提示

对于30%30\%30% 的数据，1≤n,m≤101 \leq n, m \leq 101≤n,m≤10，q=1q = 1q=1；

对于60%60\%60% 的数据，1≤n,m≤301 \leq n, m \leq 301≤n,m≤30，q≤10q \leq 10q≤10；

对于100%100\%100% 的数据，1≤n,m≤301 \leq n, m \leq 301≤n,m≤30，q≤500q \leq 500q≤500。

 

 

---

 

 

把状态看做点，转移的代价看成边，于是就变成了最短路问题。

我们把少量的有用的状态拿出来进行连边。

$\large id[i][j][k]$为空格在$\large (i, j)$的k方向的状态的编号。

然后用bfs处理出[i][j][k] 到 [i][j][p] 的路径长度连边。

还有一种转移是空格和(i, j)换位置， [i][j][k] 与 [i'][j'][k^1] 连边权1的边。

每次开始的时候把空格点跑bfs，向起点的四周连边。

然后spfa跑最短路。

 

---

 

 

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
inline int read() {
    int res=0;char ch=getchar();bool flag=0;
    while(!isdigit(ch)) {if(ch=='-')flag=1;ch=getchar();}
    while(isdigit(ch))res=(res<<3)+(res<<1)+(ch^48), ch=getchar();
    return flag ? -res : res;
}
#define reg register
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
int n, m, q;
bool mp[35][35];
int id[35][35][5], tot;

int Ex, Ey, Sx, Sy, Tx, Ty;

struct edge {
    int nxt, to, val;
}ed[35*35*35*2];
int head[35*35*4], cnt;
inline void add(int x, int y, int z)
{
    if (z == 0x3f3f3f3f) return ;
    ed[++cnt] = (edge) {head[x], y, z};
    head[x] = cnt;
}

struct date {
    int x, y, stp;
};
int stp[35][35];
int dis[35*35*8];
bool vis[35][35];
bool ex[35*35*8];

inline bool ok(int x, int y)
{
    if (!mp[x][y] and x > 0 and x <= n and y > 0 and y <= m) return 1;
    return 0;
}

inline int bfs(int sx, int sy, int tx, int ty, int fx, int fy)
{
    if (sx == tx and sy == ty) return 0;
    memset(vis, 0, sizeof vis);
    queue <date> q;
    q.push((date){sx, sy, 0});
    vis[sx][sy] = 1;
    while(!q.empty())
    {
        int x = q.front().x, y = q.front().y, tp = q.front().stp;q.pop();
        for (reg int i = 0 ; i < 4 ; i ++)
        {
            int ux = x + dx[i], uy = y + dy[i];
            if (ok(ux, uy) and !vis[ux][uy])
            {
                vis[ux][uy] = 1;
                if (ux == fx and uy == fy) continue;
                if (ux == tx and uy == ty) return tp + 1;
                q.push((date){ux, uy, tp + 1});
            }
        }
    }
    return 0x3f3f3f3f;
}

int main()
{
    memset(mp, 1, sizeof mp);
    n = read(), m = read(), q = read();
    for (reg int i = 1 ; i <= n ; i ++)
        for (reg int j = 1 ; j <= m ; j ++)
            if (read()) mp[i][j] = 0;//如果不固定就是0
    for (reg int i = 1 ; i <= n ; i ++)
        for (reg int j = 1 ; j <= m ; j ++)
            for (reg int k = 0 ; k < 4 ; k ++)
                id[i][j][k] = ++tot;
    for (reg int i = 1 ; i <= n ; i ++)
    {
        for (reg int j = 1 ; j <= m ; j ++)
        {
            if (mp[i][j]) continue;
            for (reg int k = 0 ; k < 4 ; k ++)
            {
                int tx = i + dx[k], ty = j + dy[k];
                if (ok(tx, ty)) 
                    add(id[i][j][k], id[tx][ty][k^1], 1);
            }
        }
    }
    for (reg int i = 1 ; i <= n ; i ++)
    {
        for (reg int j = 1 ; j <= m ; j ++)    
        {
            if (mp[i][j]) continue;
            for (reg int k = 0 ; k < 4 ; k ++)
            {
                int x1 = i + dx[k], y1 = j + dy[k];
                if (!ok(x1, y1)) continue;
                for (reg int p = 0 ; p < 4 ; p ++)
                {
                    int x2 = i + dx[p], y2 = j + dy[p];
                    if (k != p and ok(x2, y2))
                    {
                        int tmp = bfs(x1, y1, x2, y2, i, j);
                        if (tmp != 0x3f3f3f3f)  add(id[i][j][k], id[i][j][p], tmp);
                    }
                }
            }
        }
    }
    while(q--)
    {
        Ex = read(), Ey = read(), Sx = read(), Sy = read(), Tx = read(), Ty = read();
        if (Sx == Tx and Sy == Ty) {puts("0");continue;}
        queue <int> q;
        memset(dis, 0x3f, sizeof dis);
        for (reg int i = 0 ; i < 4 ; i ++)
        {
            int x = Sx + dx[i], y = Sy + dy[i];
            if (ok(x, y))
            {
                dis[id[Sx][Sy][i]] = bfs(Ex, Ey, x, y, Sx, Sy);
                q.push(id[Sx][Sy][i]);
            }
        }
        while(!q.empty())
        {
            int x = q.front();q.pop();
            ex[x] = 0;
            for (reg int i = head[x] ; i ; i = ed[i].nxt)
            {
                int to = ed[i].to;
                if (dis[to] > dis[x] + ed[i].val)
                {
                    dis[to] = dis[x] + ed[i].val;
                    if (!ex[to]) ex[to] = 1, q.push(to);
                }
            }
        }
        int ans = 0x3f3f3f3f;
        for (reg int i = 0 ; i < 4 ; i ++)
            ans = min(ans, dis[id[Tx][Ty][i]]);
        printf("%d\n", ans == 0x3f3f3f3f ? -1 : ans);
    }
    return 0;
}