NOIP2013提高组day2 - T3：华容道

题目链接

[NOIP2013 提高组] 华容道

题目描述

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

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

1. 在一个 $n\times m$ 棋盘上有 $n\times m$ 个格子，其中有且只有一个格子是空白的，其余 $n\times m?1$ 个格子上每个格子上有一个棋子，每个棋子的大小都是 $1\times 1$ 的；
2. 有些棋子是固定的，有些棋子则是可以移动的；
3. 任何与空白的格子相邻（有公共的边）的格子上的棋子都可以移动到空白格子上。

游戏的目的是把某个指定位置可以活动的棋子移动到目标位置。

给定一个棋盘，游戏可以玩 $q$ 次，当然，每次棋盘上固定的格子是不会变的， 但是棋盘上空白的格子的初始位置、 指定的可移动的棋子的初始位置和目标位置却可能不同。第 $i$ 次玩的时候， 空白的格子在第 $E{X}_i$ 行第 $E{Y}_i$ 列，指定的可移动棋子的初始位置为第 $S{X}_i$ 行第 $S{Y}_i$列，目标位置为第 $T{X}_i$ 行第 $T{Y}_i$ 列。

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

输入格式

第一行有 $3$个整数，每两个整数之间用一个空格隔开，依次表示 $n,m,q$；

接下来的 $n$ 行描述一个 $n\times m$ 的棋盘，每行有 $m$ 个整数，每两个整数之间用一个空格隔开，每个整数描述棋盘上一个格子的状态，$0$ 表示该格子上的棋子是固定的，$1$ 表示该格子上的棋子可以移动或者该格子是空白的。

接下来的 $q$ 行，每行包含 $6$ 个整数依次是 $E{X}_i,E{Y}_i,S{X}_i,S{Y}_i,T{X}_i,T{Y}_i$，每两个整数之间用一个空格隔开，表示每次游戏空白格子的位置，指定棋子的初始位置和目标位置。

输出格式

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

样例 #1

样例输入 #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

样例输出 #1

2
-1

提示

输入输出样例说明

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

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

移动过程如下：

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

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

数据范围

对于 $30\%$ 的数据，$1\le n,m\le 10,q=1$；

对于 $60\%$ 的数据，$1\le n,m\le 30,q\le 10$；

对于 $100\%$ 的数据，$1\le n,m\le 30,q\le 500$。

算法思想

根据题目描述，要通过一个空白格子，将指定棋子（绿色），移动到目标位置（黄色）。由于每次移动，都要借助空白格子，因此不妨将空白格子当成一颗“特殊”棋子，通过移动这颗空白棋子来完成要求，如下图所示。

可以把移动过程分成两部分：

• 首先，将空白棋子移动到绿色棋子相邻的$4$个格子上，这样才能移动绿色棋子，如下图所示。
  

由于每秒钟能进行一次移动棋子，因此可以用bfs处理将空白棋子移动到绿色棋子相邻$4$个格子上的移动步数。这样就可以建立从空白格子$(EX,EY)$指向绿色棋子$4$个相邻的点的边， $(EX,EY)\to (sx,sy,k)$，其边权就是最小移动次数。

• 其次，在有解的情况下，只需要调整空白棋子和绿色棋子的相对位置，就能将绿色棋子移动目标位置。对于绿色棋子每个相邻位置上的空白棋子都有$4$种选择，以左侧相邻的空白棋子为例，如下图所示
  • 和绿色棋子进行交换
  • 走到绿色棋子上边相邻位置
  • 走到绿色棋子右边相邻位置
  • 走到绿色棋子下边相邻位置

每种选择对应的移动次数不同，为了能够快速计算出最小步数，可以预处理出从第$i$行$j$列棋子的相邻$k$方向上的格子出发，移动到该棋子其它相邻$3$个方向上的最小步数。
据此，可以建立一条边从$(i,j,k)\to (i,j,k^{\prime })$，其中$(i,j)$表示绿色棋子所在行列，$k$和$k^{\prime }$表示相邻的不同方向，其权值就是就是移动步数。

例如：

基于上述分析，可以构建一个出一个图，将绿色棋子从初始位置移动到目标位置的最小步数，就是求图的最短路，可以使用spfa算法求解。

时间复杂度

• 预处理第$i$行$j$列的绿色棋子上在其相邻$k$方向上的格子，移动到该棋子其它相邻$3$个方向上的最小步数，需要枚举每个格子时间复杂度为$n\times m$，bfs算法处理的状态数为$n\times m\times 4$。总的时间复杂度为$O(n^2{m}^2\times 4)=900^2\times 4=3,240,000$
• spfa的时间复杂度最好情况为$O(E)$，最坏情况是$O(EV)$，其中$E$表示边数，$V$表示点数，一共有$30\times 30\times 4=3,600$个点，每个点有$4$条边，边数为$3600times4=14,400$。

代码实现

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 35, M = 3605, K = M * 4, INF = 0x3f3f3f3f;
int n, m, Q;
int g[N][N], dis1[N][N], dis2[M];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int h[M], e[K], ne[K], w[K], idx;
bool st[M];
void add(int a, int b, int c)  // 添加一条边a->b，边权为c
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
//根据行列和方向，获取点的编号
int get(int x, int y, int z)
{
    return ((x - 1) * m + y - 1) * 4 + z;
}
//(bx,by)表示空白格子，(gx,gy)表示绿色格子，d表示方向
void bfs(int bx, int by, int gx, int gy, int d)
{
    queue<PII> q;
    memset(dis1, 0x3f, sizeof dis1);
    dis1[bx][by] = dis1[gx][gy] = 0; //不能走到绿色格子，将其设为0不更新
    q.push({bx, by});
    while(q.size())
    {
        PII t = q.front(); q.pop();
        int x = t.first, y = t.second;
        for(int i = 0; i < 4; i ++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(g[a][b] && dis1[a][b] > dis1[x][y] + 1)
            {
                dis1[a][b] = dis1[x][y] + 1;
                q.push({a, b});
            }
        }
    }
    if(d == -1) return; //不建边 
    //建边(gx,gy,d)->(gx,gx,其它方向)
    int id = get(gx, gy, d);
    for(int i = 0; i < 4; i ++)
    {
        if(i != d) //其它方向
        {
            int x = gx + dx[i], y = gy + dy[i];
            if(dis1[x][y] < INF) //可以到达
                add(id, get(gx, gy, i), dis1[x][y]);
        }
    }
    //将空白格子和绿色格子交换的权值为1，方向^2可以将0->2,2->0,1->3,3->1
    add(id, get(bx, by, d ^ 2), 1);
}
int spfa(int sx, int sy, int tx, int ty)
{
    queue<int> q;
    memset(dis2, 0x3f, sizeof dis2);
    //将指定绿色格子相邻4个方向的格子作为多起点加入队列
    for(int i = 0; i < 4; i ++)
    {
        int x = sx + dx[i], y = sy + dy[i];
        if(dis1[x][y] < INF) //能够到达(x, y)
        {
            int id = get(sx, sy, i);
            dis2[id] = dis1[x][y]; //权值为到达该点的最小步数
            q.push(id);
            st[id] = true;
        }
    }
    while(q.size())
    {
        int u = q.front(); q.pop();
        st[u] = false;
        for(int i = h[u]; ~ i; i = ne[i])
        {
            int v = e[i];
            if(dis2[v] > dis2[u] + w[i])
            {
                dis2[v] = dis2[u] + w[i];
                if(!st[v])
                {
                    q.push(v);
                    st[v] = true;
                }
            }
        }
    }
    int res = INF;
    //最终答案为指定绿色棋子走到目标位置，空白格子在相邻方向上的最小值
    for(int i = 0; i < 4; i ++)
        res = min(res, dis2[get(tx, ty, i)]);
    if(res == INF) res = -1;
    return res;
}
int main()
{
    scanf("%d%d%d", &n, &m, &Q);
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            scanf("%d", &g[i][j]);
    memset(h, -1, sizeof h); //链式前向星初始化头指针
    //预处理出从第i行j列相邻k方向上的格子移动到其它相邻格子的最小步数
    for(int i = 1; i <= n; i ++)//枚举中心的格子
        for(int j = 1; j <= m; j ++)
            if(g[i][j]) //棋子不是固定的
            {
                for(int k = 0; k < 4; k ++) //枚举相邻的4个格子
                {
                    int x = i + dx[k], y = j + dy[k];
                    if(g[x][y]) bfs(x, y, i, j, k);
                }
            }
            
    while(Q --)
    {
        int ex, ey, sx, sy, tx, ty;
        scanf("%d%d%d%d%d%d", &ex, &ey, &sx, &sy, &tx, &ty);
        //特殊处理，绿色棋子在目标位置
        if(sx == tx && sy == ty) puts("0");
        else
        {
            //先处理将空白格子移动到指定棋子周围4个相邻格子上的最短距离
            bfs(ex, ey, sx, sy, -1); //方向设为-1，不用建边
            int ans = spfa(sx, sy, tx, ty);
            printf("%d\n", ans);
        }
    }
    return 0;
}