Luogu P1979 [NOIP 2013 提高组] 华容道 题解 [ 紫 ] [ 最短路 ]

华容道：很 trivial 的图论建模。

注意到 \(n,m\) 较小，直接考虑暴力思路：状态 \((a,b,c,d)\) 表示棋子位置在 \((a,b)\)，空白在 \((c,d)\) 的最小花费。把一个状态看做一个节点，跑 BFS 即可。时间复杂度 \(O(qn^2m^2)\)，小常数可以卡过去。

套路地，进一步观察路径，发现最终路径一定是两段：

• 空白格子移动到棋子旁边。
• 空白格子和棋子一起移动到终点。

先考虑第一段路径怎么做，因为给定的网格是固定不变的，所以考虑预处理。直接跑 \(O(n^2m^2)\) 的全源 BFS 是不可行的，因为第一段路线中棋子是不能移动的；但是 \(O(n^3m^3)\) 枚举棋子位置又会 TLE。继续观察，发现棋子的位置不需要枚举这么多，因为我们实际用的时候只需要用到棋子在与目标四连通的格子里时，空白格子与目标点的距离。于是只需要枚举与目标四连通的格子，然后预处理即可。时间复杂度 \(O(n^2m^2)\)。

继续考虑第二段怎么做，注意到移动棋子的时候棋子和空白格子总是相邻的，所以考虑记录空白格子相对棋子的方位即可做到 \(O(nm)\) 级别的状态数。建边有两种类型：

• 交换空白格子与棋子，边权为 \(1\)。
• 改变空白格子相对棋子的方位，边权为空白格子移动的距离。

发现第二种建边方式恰好在前面预处理完了，于是跑一遍单源最短路即可。时间复杂度 \(O(nm\log nm)\)。

总体时间复杂度 \(O(n^2m^2+qnm\log nm)\)，可以轻松通过。

#include <bits/stdc++.h>
#define fi first
#define se second
#define eb(x) emplace_back(x)
#define pb(x) push_back(x)
#define lc(x) (tr[x].ls)
#define rc(x) (tr[x].rs)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ldb;
using pi=pair<int,int>;
const int N=35;
const int inf=0x3f3f3f3f;
int n,m,q,kdis[N][N][4][N][N],dis[N][N][4];
int gox[]={0,0,1,-1};
int goy[]={1,-1,0,0};
bitset<N>a[N];
bool legal(int x,int y)
{
    return (1<=x&&x<=n&&1<=y&&y<=m);
}
void caldis(int bx,int by,int sx,int sy,int tp)
{
    if(bx==sx&&by==sy)return;
    queue<pi>q;
    q.push({sx,sy});
    kdis[bx][by][tp][sx][sy]=0;
    while(!q.empty())
    {
        pi u=q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            int tx=u.fi+gox[i],ty=u.se+goy[i];
            if(legal(tx,ty)&&a[tx][ty]==1&&(tx!=bx||ty!=by)&&kdis[bx][by][tp][tx][ty]>=inf)
            {
                q.push({tx,ty});
                kdis[bx][by][tp][tx][ty]=kdis[bx][by][tp][u.fi][u.se]+1;
            }
        }
    }
}
void init()
{
    memset(kdis,0x3f,sizeof(kdis));
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            for(int x=0;x<4;x++)
                if(legal(i+gox[x],j+goy[x]))
                    caldis(i,j,i+gox[x],j+goy[x],x);
}
struct Node{
    int x,y,tp,dis;
    bool operator>(const Node &t)const{
        return dis>t.dis;
    }
};
void solve()
{
    int ex,ey,sx,sy,px,py;
    cin>>ex>>ey>>sx>>sy>>px>>py;
    if(sx==px&&sy==py)
    {
        cout<<0<<'\n';
        return;
    }
    memset(dis,0x3f,sizeof(dis));
    priority_queue<Node,vector<Node>,greater<Node> >q;
    bitset<4>vis[N][N];
    for(int i=0;i<4;i++)
    {
        int tx=sx+gox[i],ty=sy+goy[i];
        if(legal(tx,ty)&&a[tx][ty]==1&&kdis[sx][sy][i][ex][ey]<inf)
        {
            q.push({tx,ty,i^1,kdis[sx][sy][i][ex][ey]+1});
            dis[tx][ty][i^1]=kdis[sx][sy][i][ex][ey]+1;
            q.push({sx,sy,i,kdis[sx][sy][i][ex][ey]});
            dis[sx][sy][i]=kdis[sx][sy][i][ex][ey];
        }
    }
    while(!q.empty())
    {
        Node u=q.top();
        q.pop();
        if(vis[u.x][u.y][u.tp]==1)continue;
        vis[u.x][u.y][u.tp]=1;
        if(legal(u.x+gox[u.tp],u.y+goy[u.tp])&&dis[u.x+gox[u.tp]][u.y+goy[u.tp]][u.tp^1]>u.dis+1)
        {
            dis[u.x+gox[u.tp]][u.y+goy[u.tp]][u.tp^1]=u.dis+1;
            q.push({u.x+gox[u.tp],u.y+goy[u.tp],u.tp^1,u.dis+1});
        }
        for(int i=0;i<4;i++)
        {
            if(i==u.tp)continue;
            int tx=u.x+gox[i],ty=u.y+goy[i];
            if(legal(tx,ty)&&u.dis+kdis[u.x][u.y][u.tp][tx][ty]<dis[u.x][u.y][i])
            {
                dis[u.x][u.y][i]=u.dis+kdis[u.x][u.y][u.tp][tx][ty];
                q.push({u.x,u.y,i,dis[u.x][u.y][i]});
            }
        }
    }
    int ans=inf;
    for(int i=0;i<4;i++)
        ans=min(ans,dis[px][py][i]);
    if(ans>=inf)
        cout<<-1<<"\n";
    else
        cout<<ans<<'\n';
}
int main()
{
    //freopen("sample.in","r",stdin);
    //freopen("sample.out","w",stdout);
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    cin>>n>>m>>q;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            char c;
            cin>>c;
            a[i][j]=(c=='0'?0:1);
        }
    }
    init();
    while(q--)
        solve();
    return 0;
}