传送门
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\)