codevs 3290 华容道

go to the problem–>
*对于题解的整理？？迷。。。

题目描述 Description

小 B 最近迷上了华容道，可是他总是要花很长的时间才能完成一次。于是，他想到用编程来完成华容道：给定一种局面，华容道是否根本就无法完成，如果能完成，最少需要多少时间。
小 B 玩的华容道与经典的华容道游戏略有不同，游戏规则是这样的：

在一个 n*m 棋盘上有 n*m 个格子，其中有且只有一个格子是空白的，其余 n*m-1个格子上每个格子上有一个棋子，每个棋子的大小都是 1*1 的；
有些棋子是固定的，有些棋子则是可以移动的；
任何与空白的格子相邻（有公共的边）的格子上的棋子都可以移动到空白格子上。 游戏的目的是把某个指定位置可以活动的棋子移动到目标位置。
给定一个棋盘，游戏可以玩 q 次，当然，每次棋盘上固定的格子是不会变的，但是棋盘上空白的格子的初始位置、指定的可移动的棋子的初始位置和目标位置却可能不同。第 i 次玩的时候，空白的格子在第 EX_i 行第 EY_i 列，指定的可移动棋子的初始位置为第 SX_i 行第 SY_i 列，目标位置为第 TX_i 行第 TY_i 列。
假设小 B 每秒钟能进行一次移动棋子的操作，而其他操作的时间都可以忽略不计。请你告诉小 B 每一次游戏所需要的最少时间，或者告诉他不可能完成游戏。

输入描述 Input Description

第一行有 3 个整数，每两个整数之间用一个空格隔开，依次表示 n、m 和 q；
接下来的 n 行描述一个 n*m 的棋盘，每行有 m 个整数，每两个整数之间用一个空格隔开，每个整数描述棋盘上一个格子的状态，0 表示该格子上的棋子是固定的，1 表示该格子上的棋子可以移动或者该格子是空白的。
接下来的 q 行，每行包含 6 个整数依次是 EX_i、EY_i、SX_i、SY_i、TX_i、TY_i，每两个整数之间用一个空格隔开，表示每次游戏空白格子的位置，指定棋子的初始位置和目标位置。

输出描述 Output Description

输出有 q 行，每行包含 1 个整数，表示每次游戏所需要的最少时间，如果某次游戏无法完成目标则输出-1。

样例输入 Sample Input

3 4 2
0 1 1 1
0 1 1 0
0 1 0 0
3 2 1 2 2 2
1 2 2 2 3 2

样例输出 Sample Output

2
-1

思路：

移动棋子太麻烦，转换角度，移动空白格子。

指定棋子自己肯定无法移动，若要移动身边必须靠着空白格子。

空白格子初始时有可能并不靠着指定棋子的初始位置，因此需要先将空白格子移动指定棋子身边。

指定棋子若要移动到身边某一位置时空白格子必须预先到达那个位置。并且在移动后两者的位置互换。

空白格子移动到某一位置所花费的时间可以用bfs求出。（小技巧：空白格子从(i,j)到(x,y)和从(x,y)到(i,j)是一样的）

指定棋子移动到某一位置所花费的时间与他目前的状态有关：指定棋子的位置、空白格子的位置、要移动到的位置。

为了节省空间，空白格子的位置和要移动到的位置可以由他们与指定棋子的位置关系代替。

由于题目是给定棋盘，有q次询问，询问中棋盘不变。因此考虑对棋盘进行预处理，询问时只需求解。

设 move[i][j][k][e]表示空白格子在棋子的k方位时，位置为i，j的棋子要移动到方位e的位置所需的花费。

可知 move[i][j][k][e]=空白格子移动到指定位置的花费+1.

预处理出move数组后，对于每次询问，设状态为(x,y,k)，其中k表示空白格子相对于x,y的位置。设转移到位置i,j ,可知 状态(x,y,k)与状态(i,j,k’)间抽象出了一条权值为move[i][j][k][e]的边。

SPFA求初始状态到目标状态的最短路。

得解。

*特别的：

1.指定棋子移动前空白格子的移动不能通过该棋子。
2.记得预处理。
3.记得判断边界。

代码ヾﾉ≧∀≦)o

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
using namespace std;

const int inf=1061109567;
int n,m,q,ex,ey,sx,sy,tx,ty,ans;
int a[35][35],move[35][35][5][5],dis[35][35][5];
int used[35][35],Used[35][35][5];
int X[4]={-1,1,0,0},  // 0:up 1:down 2:right 3:left
    Y[4]={0,0,1,-1};
struct maple{
    int x,y,k;
};

bool can(int x,int y)
{
    if(x<1||x>n||y<1||y>m||!a[x][y]) return false;
    return true;
}
int Bfs(int fx,int fy,int tx,int ty,int I,int J)
{
    if(fx==tx&&fy==ty) return 0;
    memset(used,0,sizeof(used));
    queue<maple> Q;
    Q.push((maple){fx,fy,0});
    used[fx][fy]=1;
    used[I][J]=1;
    while(!Q.empty())
    {
        maple b=Q.front();
        Q.pop();
        for(int i=0;i<4;++i)
        {
            int x=b.x+X[i],y=b.y+Y[i];
            if(!used[x][y]&&can(x,y))
            {
                used[x][y]=1;
                Q.push((maple){ x,y,b.k+1});
                if(x==tx&&y==ty) return b.k+1;
            }
        }
    }
    return inf;
}
void Done_move()
{
    memset(move,63,sizeof(move));
    for(int i=1;i<=n;++i)
       for(int j=1;j<=m;++j)
         if(a[i][j])
           for(int k=0;k<4;++k)
           {
              int x=i+X[k],y=j+Y[k];
              if(!can(x,y)) continue;
              for(int e=0;e<4;++e)
              {
                  int xx=i+X[e],yy=j+Y[e];
                  if(!can(xx,yy))  continue;
                  if(k>e) move[i][j][k][e]=move[i][j][e][k];
                  else move[i][j][k][e]=Bfs(x,y,xx,yy,i,j)+1;
              }
           }
}
void SPFA()
{
    if(sx==tx&&sy==ty) {
        printf("0\n");
        return ;
    }
    queue<maple>Q;
    ans=inf;
    memset(dis,63,sizeof(dis));
    memset(Used,0,sizeof(Used));
    for(int i=0;i<4;++i)
    {
        int x=sx+X[i],y=sy+Y[i];
        if(!can(x,y)) continue;
        Q.push((maple){sx,sy,i});
        Used[sx][sy][i]=1;
        dis[sx][sy][i]=Bfs(ex,ey,x,y,sx,sy);
    }
    while(!Q.empty())
    {
        maple b=Q.front();
        Q.pop();
        Used[b.x][b.y][b.k]=0;
        for(int i=0;i<4;++i)
        {
            int x=b.x+X[i],y=b.y+Y[i],k=i;
            if(i==0||i==2) ++k;
            else --k;
            if(can(x,y)&&dis[x][y][k]>dis[b.x][b.y][b.k]+move[b.x][b.y][b.k][i])
            {
                dis[x][y][k]=dis[b.x][b.y][b.k]+move[b.x][b.y][b.k][i];
                if(!Used[x][y][k]) 
                {
                    Q.push((maple){x,y,k});
                    Used[x][y][k]=1;
                }
            }
        }
    }
    for(int i=0;i<4;++i) ans=min(ans,dis[tx][ty][i]);
    if(ans<inf) printf("%d\n",ans);
    else printf("-1\n");
}
int main()
{
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=n;++i)
      for(int j=1;j<=m;++j)
         scanf("%d",&a[i][j]);
    Done_move();
    for(int i=1;i<=q;++i)
    {
        scanf("%d%d%d%d%d%d",&ex,&ey,&sx,&sy,&tx,&ty);
        SPFA();
    }
    return 0;
}