[NOIP2013提高组]华容道

这道题第一眼看是暴力，然后发现直接暴力会TLE。

把问题转换一下：移动空格到处跑，如果空格跑到指定位置的棋子，交换位置。

这个可以设计一个状态：$[x1][y1][x2][y2]$，表示空格在$(x1,\ y1)$，棋子在$(x2,\ y2)$的状态，可以向四个方向进行转移。

直接转移，对于每一组询问，都要用 $O(n^4)$ 的时间处理，所以复杂度是 $O(n^4 \times q)$。$70pts$。

观察发现有很多状态是无用状态，只有指定棋子的上下左右四个位置的状态有价值。

然后建个图，会发现不需要在询问时处理，跑一遍最短路，即可AC。

复杂度：$O(n^4)\ +\ O(n^2\ logn \times q)$

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <queue>

 using namespace std;

 #define re register
 #define LL long long
 #define rep(i, x, y) for (register int i = x; i <= y; ++i)
 #define repd(i, x, y) for (register int i = x; i >= y; --i)
 #define maxx(a, b) a = max(a, b)
 #define minn(a, b) a = min(a, b)
 #define inf 1e9
 #define linf 1e17

 inline int read() {
     re int w = , f = ; char c = getchar();
     while (!isdigit(c)) f = c == '-' ? - : f, c = getchar();
     while (isdigit(c)) w = (w << ) + (w << ) + (c ^ ), c = getchar();
     return w * f;
 }

 const int maxn =  + ;

 struct State {
     int x, y, d;
 };

 queue<State> q;

 struct Edge {
     int u, v, w, pre;
 };

 inline int convert(int x, int y, int d) {
     return x *  + y *  + d;
 }

 struct Node {
     int u, d;
     bool operator < (const Node &rhs) const {
         return d > rhs.d;
     }
 };

 priority_queue <Node> Q;

 struct Graph {
     Edge edges[maxn * maxn * maxn];
     int G[maxn * maxn * maxn], n, m;
     int d[maxn * maxn * maxn], vis[maxn * maxn * maxn];
     void init(int n) {
         this->n = n;
         m = ;
         memset(G, , sizeof(G));
     }
     void AddEdge(int u, int v, int w) {
         edges[++m] = (Edge){u, v, w, G[u]};
         G[u] = m;
     }
     void dijkstra() {
         memset(vis, , sizeof(vis));
         while (!Q.empty()) {
             re Node head = Q.top(); Q.pop();
             int u = head.u;
             if (vis[u]) continue;
             vis[u] = ;
             for (re int i = G[u]; i; i = edges[i].pre) {
                 Edge &e = edges[i];
                 if (!vis[e.v] && d[u] + e.w < d[e.v]) {
                     d[e.v] = d[u] + e.w;
                     Q.push((Node){e.v, d[e.v]});
                 }
             }
         }
     }
 } G;

 int fx[] = {, , , -};
 int fy[] = {, , -, };

 int n, m, t;
 int a[maxn][maxn], vis[maxn][maxn], dis[maxn][maxn];

 void bfs(int X, int Y) {
     memset(dis, 0x3f, sizeof(dis));
     dis[X][Y] = ;
     q.push((State){X, Y, });
     while (!q.empty()) {
         State head = q.front(); q.pop();
         dis[head.x][head.y] = head.d;
         rep(i, , ) {
             re int x = head.x + fx[i], y = head.y + fy[i];
             if (a[x][y] && !vis[x][y]) {
                 vis[x][y] = ;
                 dis[x][y] = head.d + ;
                 q.push((State){x, y, dis[x][y]});
             }
         }
     }
 }

 int main() {
     n = read(), m = read(), t = read();

     rep(i, , n)
         rep(j, , m)
             a[i][j] = read();

     G.init(n * n * );

     rep(X, , n)
         rep(Y, , m)
             if (a[X][Y]) {
                 rep(i, , ) {
                     re int x = X + fx[i], y = Y + fy[i];
                     if (a[x][y]) {
                         memset(vis, , sizeof(vis));
                         vis[x][y] = vis[X][Y] = ;
                         bfs(x, y);
                         rep(j, , ) {
                             re int x2 = X + fx[j], y2 = Y + fy[j];
                             if (i == j || !a[x2][y2]) continue;
                             G.AddEdge(convert(X, Y, i), convert(X, Y, j), dis[x2][y2]);
                         }
                     }
                 }
                 if (a[X][Y + ]) G.AddEdge(convert(X, Y, ), convert(X, Y + , ), );
                 if (a[X + ][Y]) G.AddEdge(convert(X, Y, ), convert(X + , Y, ), );
                 if (a[X][Y - ]) G.AddEdge(convert(X, Y, ), convert(X, Y - , ), );
                 if (a[X - ][Y]) G.AddEdge(convert(X, Y, ), convert(X - , Y, ), );
             }

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

     while (t--) {
         Ex = read(), Ey = read(), Sx = read(), Sy = read(), Tx = read(), Ty = read();

         if (Sx == Tx && Sy == Ty) {
             printf("0\n");
             continue;
         }

         memset(vis, , sizeof(vis));
         vis[Ex][Ey] = vis[Sx][Sy] = ;
         bfs(Ex, Ey);
         memset(G.d, 0x3f, sizeof(G.d));
         rep(i, , ) {
             Q.push((Node){convert(Sx, Sy, i), dis[Sx + fx[i]][Sy + fy[i]]});
             G.d[convert(Sx, Sy, i)] = dis[Sx + fx[i]][Sy + fy[i]];
         }
         G.dijkstra();

         re int ans = inf;
         rep(i, , )
             if (a[Tx + fx[i]][Ty + fy[i]]) minn(ans, G.d[convert(Tx, Ty, i)]);
         if (ans == inf) printf("-1\n");
         else printf("%d\n", ans);
     }

     return ;
 }