传送门
Luogu

解题思路

预支一点东西：
这题其实有着更为思维的图模型，还十分考验码力，不简单啊 这居然是联赛题
讲正解：
显然我们对于一种合法方案，空格子肯定是一直围绕着特定棋子反复横跳的。
所以说我们可以先预处理一下：对于任何一种合法的情况，求出空格在指定棋子的四个方向横跳的最小步数，这个可以通过多次 \(\text{BFS}\) 来求。
然后考虑处理询问。
不难想到任何一种走法都是先让空格来到指定棋子旁，然后进行上面提到的反复横跳，最后空格也一定会与指定棋子相邻。
所以说，我们就对于每一种指定棋子和空格的摆放情况创建一个节点，通过空格的横跳和指定棋子和空格的交换，也就是摆放情况的变化来连边。
每次询问时，我们先让空格来到指定棋子旁（这个需要枚举四个不同方向，当然要合法），
然后多源最短路，最后枚举一下终止状况，取最小步数的方案作为答案就好了。
说是这么说，其实码起来细节多得不得了啊。。。

细节注意事项

• 爆搜题，你们懂得。。。

参考代码

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <ctime>
#include <queue>
#define rg register
using namespace std;
template < typename T > inline void read(T& s) {
    s = 0; int f = 0; char c = getchar();
    while (!isdigit(c)) f |= c == '-', c = getchar();
    while (isdigit(c)) s = s * 10 + (c ^ 48), c = getchar();
    s = f ? -s : s;
}

const int _ = 32;
const int __ = 10005;
const int dx[] = { -1, 0, 0, 1 };
const int dy[] = { 0, -1, 1, 0 };

int n, m, q, a[_][_];
int f[4][_][_][_][_], vis[_][_];
int Vis[__], dis[__];
struct node { int x, y; } ;

int tot, head[__], nxt[__ << 3], ver[__ << 3], w[__ << 3];
inline void Add_edge(int u, int v, int d)
{ nxt[++tot] = head[u], head[u] = tot, ver[tot] = v, w[tot] = d; }

inline int id(int x, int y, int t) { return (x - 1) * 120 + (y - 1) * 4 + t; }

inline void calc(int sx, int sy) {
    static queue < node > Q;
    for (rg int k = 0; k < 4; ++k) {
        memset(vis, -1, sizeof vis);
        int x = sx + dx[k], y = sy + dy[k];
        if (x < 1 || x > n || y < 1 || y > m) continue;
        vis[x][y] = 1, f[k][sx][sy][sx][sy] = 0, Q.push((node) { sx, sy });
        Add_edge(id(sx, sy, 3 - k), id(x, y, k), 1);
        while (!Q.empty()) {
            node u = Q.front(); Q.pop();
            int x = u.x, y = u.y;
            for (rg int t = 0; t < 4; ++t) {
                int xx = x + dx[t], yy = y + dy[t];
                if (xx < 1 || xx > n || yy < 1 || yy > m) continue;
                if (vis[xx][yy] != -1 || !a[xx][yy] || (xx == sx && yy == sy)) continue;
                f[k][sx][sy][xx][yy] = f[k][sx][sy][x][y] + 1;
                vis[xx][yy] = 1, Q.push((node) { xx, yy });
            }
        }
        for (rg int t = 0; t < 4; ++t) {
            int xx = x + dx[t], yy = y + dy[t];
            if (k + t == 3 || f[k][sx][sy][xx][yy] == 0x3f3f3f3f) continue;
            Add_edge(id(sx, sy, 3 - k), id(xx, yy, t), f[k][sx][sy][xx][yy]);
        }
    }
}

inline void init() {
    memset(f, 0x3f, sizeof f);
    for (rg int i = 1; i <= n; ++i)
        for (rg int j = 1; j <= m; ++j)
            if (a[i][j]) calc(i, j);
}

inline void bfs(int ex, int ey, int sx, int sy) {
    static queue < node > Q;
    Q.push((node) { ex, ey });
    vis[ex][ey] = 0;
    while (!Q.empty()) {
        node u = Q.front(); Q.pop();
        int x = u.x, y = u.y;
        for (rg int k = 0; k < 4; ++k) {
            int xx = x + dx[k], yy = y + dy[k];
            if (xx < 1 || xx > n || yy < 1 || yy > m) continue;
            if (!a[xx][yy] || vis[xx][yy] != -1 || (xx == sx && yy == sy)) continue;
            vis[xx][yy] = vis[x][y] + 1, Q.push((node) { xx, yy });
        }
    }
}

inline void Dijkstra(int sx, int sy) {
    static priority_queue < pair < int, int > > Q;
    for (rg int k = 0; k < 4; ++k) {
        int xx = sx + dx[k], yy = sy + dy[k];
        if (xx < 1 || xx > n || yy < 1 || yy > m || !a[xx][yy]) continue;
        int ID = id(xx, yy, k);
        dis[ID] = vis[xx][yy] == -1 ? 0x3f3f3f3f : vis[xx][yy];
        Q.push(make_pair(-dis[ID], ID));
    }
    while (!Q.empty()) {
        int u = Q.top().second; Q.pop();
        if (Vis[u]) continue; Vis[u] = 1;
        for (rg int i = head[u]; i; i = nxt[i]) {
            int v = ver[i];
            if (dis[v] > dis[u] + w[i])
                dis[v] = dis[u] + w[i], Q.push(make_pair(-dis[v], v));
        }
    }
}

inline void solve() {
    memset(Vis, 0, sizeof Vis);
    memset(vis, -1, sizeof vis);
    memset(dis, 0x3f, sizeof dis);
    int ex, ey, sx, sy, tx, ty;
    read(ex), read(ey), read(sx), read(sy), read(tx), read(ty);
    if (sx == tx && sy == ty) { puts("0"); return ; }
    bfs(ex, ey, sx, sy), Dijkstra(sx, sy);
    int ans = 0x3f3f3f3f;
    for (rg int i = 0; i < 4; ++i) {
        int x = tx + dx[i], y = ty + dy[i];
        if (x < 1 || x > n || y < 1 || y > m) continue;
        ans = min(ans, dis[id(x, y, i)]);
    }
    if (ans == 0x3f3f3f3f) puts("-1"); else printf("%d\n", ans);
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("in.in", "r", stdin);
#endif
    read(n), read(m), read(q);
    for (rg int i = 1; i <= n; ++i)
        for (rg int j = 1; j <= m; ++j) read(a[i][j]);
    init();
    while (q--) solve();
    return 0;
}

完结撒花 \(qwq\)