【最短路】【bfs】[NOIP2013] codevs3290 华容道

题目点这里

记得这题暴力有70...十分良心，然而它卡A*……（好像A*的估值很忧伤）

本来YY出了很诡异的姿势。。然后发现很难写……想弃疗……

最后还是按网上流传的方法做的..不过网上的代码都好繁琐啊 = =差评……

太久没有写代码真的生疏了不少..代码能力掉的很厉害。所以啊很多东西很久不碰也许就会忘掉了

还好最后还是成功AC掉了，谢天谢地

注意：1.加边不能加双向，因为虚拟节点可能会捣乱。2.变量相当多，一定要仔细

思路：要将目标旗子移动到目标位置首先要先把空格移到它旁边然后再将它和空格一起往目标位置移动。

而后面这个阶段是可以预处理的。因为棋盘可以拿来放旗子和空格的位置是不会变的，那么每个状态之间的最小步数也是不会变的。

对于每个合法点A（x，y），枚举一个E（ex，ey）表示空格的位置，和一个T（tx，ty）表示要把目标棋子从这个格子移向的位置。

然后就可以bfs算出将棋子从A移到T，将空格从E移到A需要的最小步数。

然后用各个状态和他们互相通达的最小步数建图。询问的时候在新建的图上spfa即可。

状态需要hash，用map也行。

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

using namespace std;

typedef pair<int, int> node;
const int dx[] = { 1, -1, 0, 0 }, dy[] = { 0, 0, 1, -1 }; // 0下， 1上， 2左， 3右
const int inf = 0x3f3f3f3f;

int N, M, Q, map[35][35];
int Hash[35][35][4];

int head[5005], k = 1;
struct ed {
    int v, w, next;
}e[300005];

inline void adde(int u, int v, int w)
{
    e[k] = (ed) { v, w, head[u] };
    head[u] = k ++;
}

int Dis[5005], vis[5005];
queue <int> que;

int spfa(int S, int T)
{
    memset(Dis, inf, sizeof(Dis)); memset(vis, 0, sizeof(vis));
    que.push(S); Dis[S] = 0;
    while (que.size()) {
        int u = que.front(); que.pop(); vis[u] = 0;
        for (int i = head[u]; i; i = e[i].next) {
            int v = e[i].v;
            if (Dis[v] > Dis[u] + e[i].w) {
                Dis[v] = Dis[u] + e[i].w;
                if (! vis[v]) { que.push(v); vis[v] = 1; }
            }
        }
    }
    return (Dis[T] ^ inf) ? Dis[T] : -1;
}

int dis[35][35];
queue <node> q;

int bfs(int sx, int sy, int tx, int ty)
{
    if (sx == tx && sy == ty) return 0;
    memset(dis, -1, sizeof(dis)); dis[sx][sy] = 0;
    while (q.size()) q.pop(); q.push((node) { sx, sy });
    while (q.size()) {
        node temp = q.front(); q.pop();
        for (int d = 0; d < 4; ++ d) {
            int nx = temp.first + dx[d], ny = temp.second + dy[d];
            if ((! map[nx][ny]) || (dis[nx][ny] ^ (-1))) continue;
            dis[nx][ny] = dis[temp.first][temp.second] + 1;
            if (nx == tx && ny == ty) return dis[nx][ny];
            q.push((node) { nx, ny });
        }
    }
    return inf;
}

inline void expand(int x, int y)
{
    for (int ed = 0; ed < 4; ++ ed) {
        int ex = x + dx[ed], ey = y + dy[ed]; if (! map[ex][ey]) continue;
        for (int td = 0; td < 4; ++ td) {
            int tx = x + dx[td], ty = y + dy[td]; if (! map[tx][ty]) continue;
            int temp = bfs(ex, ey, tx, ty);
            // temp : 将棋子从（x，y）移到（tx，ty），将空格移到（x，y）的位置需要的最小步数。
            if (temp ^ inf) adde(Hash[x][y][ed], Hash[tx][ty][td ^ 1], temp + 1);
        }
    }
}

int main()
{
    cin >> N >> M >> Q; int h = 0;
    for (int i = 1; i <= N; ++ i) {
        for (int j = 1; j <= M; ++ j) {
            scanf("%1d", &map[i][j]);
            for (int d = 0; d < 4; ++ d) Hash[i][j][d] = ++ h;
            // 状态编号：目标棋子在（i，j），空格在其d的位置。
        }
    }
    for (int i = 1; i <= N; ++ i) {
        for (int j = 1; j <= M; ++ j) if (map[i][j]) {
            map[i][j] = 0; expand(i, j); map[i][j] = 1;
        }
    }
    
    while (Q --) {
        int ex, ey, sx, sy, tx, ty;
        scanf("%d%d%d%d%d%d", &ex, &ey, &sx, &sy, &tx, &ty);
        if (!map[ex][ey] || !map[sx][sy] || !map[tx][ty]) { puts("-1"); continue; }
        if (sx == tx && sy == ty) { puts("0"); continue; }
        
        int S = ++ h, T = ++ h; // 虚拟始终点，每次都要新建一个。
        map[sx][sy] = 0;
        for (int d = 0; d < 4; ++ d) {
            int nx = sx + dx[d], ny = sy + dy[d]; if (! map[nx][ny]) continue;
            int temp = bfs(ex, ey, nx, ny);
            // temp : 将空格移到目标棋子旁边的最小步数。
            if (temp ^ inf) adde(S, Hash[sx][sy][d], temp);
        }
        map[sx][sy] = 1;
        for (int d = 0; d < 4; ++ d) {
            int nx = tx + dx[d], ny = ty + dy[d];
            if (map[nx][ny]) adde(Hash[tx][ty][d], T, 0);
            // 四个满足目标的状态。
        }
        printf("%d\n", spfa(S, T));
    }
    
    return 0;
}