题目大意
小 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 每一次游戏所需要的最少时间，或者告诉他不可能完成游戏。
题解
最简单的方法莫过于让空格瞎走，此法能得到70分（当初模拟时太过于紧张只想得那30分，数组开小了。。。记住，数组够，就开大）。
我们想到，要想让移动过的控制的棋子向相邻的格子$q$动，空格必须先到达$q$。移动的时间有多长呢？因为规定了控制的棋子移动过，故之间空格一定在控制的棋子的另一个相邻格子$p$中，空格所要移动的距离便是从$p$到$q$避开棋子所在位置的最短路径长度$d$。也就是说，我们用控制棋子的位置和空格的位置作为状态（棋子移动过，故空格必定与控制棋子相邻，故可以用一条连接两个格子对应节点的有向边来表示），表示空格移动一步的两个状态间的转移权值为$d+1$。在一个新图中，把状态作为状态节点，转移为状态边，虚拟一个状态起始点向所有to节点为控制节点的边对应的状态节点连一条空格初始位置到该边from点的最短距离的状态边，所有to节点为终止节点的边对应的状态节点与虚拟终止节点连一条边权为0的状态边，跑一遍Dijkstra即可。
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int MAX_ROW = 35, MAX_COL = 35, INF = 0x3f3f3f3f;
bool IsWall[MAX_ROW][MAX_COL];
int TotRow, TotCol;
int StComRow, StComCol, StEmpRow, StEmpCol, TarComRow, TarComCol;
struct SPGraph//shortest path
{
static const int MAX_NODE = MAX_ROW * MAX_COL * 4;
static const int MAX_EDGE = MAX_ROW * MAX_COL * 16;
struct Node;
struct Edge;
struct Node
{
Edge *Head;
int Dist;
bool Done;
}_nodes[MAX_NODE], *Start;
int TotNode;
struct Edge
{
Node *To, *From;
Edge *Next;
int Weight;
}_edges[MAX_EDGE];
int _eCount;
struct HeapNode
{
Node *Cur;
int Dist;
HeapNode(Node *cur, int dist):Cur(cur),Dist(dist){}
bool operator < (const HeapNode& a) const
{
return Dist > a.Dist;
}
};
void Init(int n, int s)
{
TotNode = n;
Start = _nodes + s;
}
void AddEdge(int u, int v, int w)
{
Edge *e = _edges + ++_eCount;
e->To = _nodes + v;
e->From = _nodes + u;
e->Weight = w;
e->Next = _nodes[u].Head;
_nodes[u].Head = e;
}
void PopEdge()
{
Edge *e = _edges + _eCount;
Edge **next = &e->From->Head;
while (true)
{
if (*next == e)
{
*next = e->Next;
_eCount--;
return;
}
else
next = &(*next)->Next;
}
}
void Dijkstra()
{
static priority_queue<HeapNode> q;
for (int i = 1; i <= TotNode; i++)
{
_nodes[i].Dist = INF;
_nodes[i].Done = false;
}
Start->Dist = 0;
q.push(HeapNode(Start, 0));
while (!q.empty())
{
HeapNode curHeapNode = q.top();
q.pop();
Node *cur = curHeapNode.Cur;
if (cur->Done)
continue;
cur->Done = true;
for (Edge *e = cur->Head; e; e = e->Next)
{
if (cur->Dist + e->Weight < e->To->Dist)
{
e->To->Dist = cur->Dist + e->Weight;
q.push(HeapNode(e->To, e->To->Dist));
}
}
}
}
}s;
struct OrgGraph
{
static const int MAX_EDGE = MAX_ROW * MAX_COL * 4;
struct Node;
struct Edge;
struct Node
{
Edge *Head;
int Dist;
int Row, Col;
}_nodes[MAX_ROW][MAX_COL];
struct Edge
{
Node *To, *From;
Edge *Next;
}_edges[MAX_EDGE];
int _eCount;
void AddEdge(int row1, int col1, int row2, int col2)
{
Node *from = _nodes[row1] + col1, *to = _nodes[row2] + col2;
Edge *e = _edges + ++_eCount;
e->To = to;
e->From = from;
e->Next = from->Head;
from->Head = e;
}
void GetDist_Bfs(Node *start, Node *skip)
{
static queue<Node*> q;
while (!q.empty())
q.pop();
for (int row = 1; row <= TotRow; row++)
for (int col = 1; col <= TotCol; col++)
_nodes[row][col].Dist = -1;
start->Dist = 0;
q.push(start);
while (!q.empty())
{
Node *cur = q.front();
q.pop();
for (Edge *e = cur->Head; e; e = e->Next)
{
if (e->To == skip)
continue;
if (e->To->Dist >= 0)
continue;
e->To->Dist = cur->Dist + 1;
q.push(e->To);
}
}
}
}g;
void BuildG()
{
for (int row = 1; row <= TotRow; row++)
for (int col = 1; col <= TotCol; col++)
g._nodes[row][col].Row = row, g._nodes[row][col].Col = col;
const int Dir[4][2] = { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };
for (int row = 1; row <= TotRow; row++)
for (int col = 1; col <= TotCol; col++)
{
if (IsWall[row][col])
continue;
for (int i = 0; i < 4; i++)
{
int row1 = row + Dir[i][0], col1 = col + Dir[i][1];
if (IsWall[row1][col1])
continue;
g.AddEdge(row, col, row1, col1);
}
}
}
void BuildS()
{
s.Init(g._eCount + 2, g._eCount + 1);
for (int i = 1; i <= g._eCount; i++)
{
OrgGraph::Edge *eCur = g._edges + i;
g.GetDist_Bfs(eCur->From, eCur->To);
for (OrgGraph::Edge *e = eCur->To->Head; e; e = e->Next)
{
if (e->To->Dist == -1)
continue;
s.AddEdge(eCur - g._edges, e - g._edges, e->To->Dist + 1);
}
}
}
int GetAns()
{
int cnt = 0;
OrgGraph::Node *StCom = g._nodes[StComRow] + StComCol;
OrgGraph::Node *StEmp = g._nodes[StEmpRow] + StEmpCol;
OrgGraph::Node *TarCom = g._nodes[TarComRow] + TarComCol;
if (StCom == TarCom)
return 0;
g.GetDist_Bfs(StEmp, StCom);
for (OrgGraph::Edge *e1 = StCom->Head; e1; e1 = e1->Next)
for (OrgGraph::Edge *e2 = e1->To->Head; e2; e2 = e2->Next)
{
if (e2->To != StCom)
continue;
if (e2->From->Dist == -1)
continue;
s.AddEdge(g._eCount + 1, e2 - g._edges, e2->From->Dist);
cnt++;
}
for (OrgGraph::Edge *e1 = TarCom->Head; e1; e1 = e1->Next)
for (OrgGraph::Edge *e2 = e1->To->Head; e2; e2 = e2->Next)
{
if (e2->To != TarCom)
continue;
s.AddEdge(e2 - g._edges, g._eCount + 2, 0);
cnt++;
}
s.Dijkstra();
while (cnt--)
s.PopEdge();
int ans = s._nodes[g._eCount + 2].Dist;
if (ans == INF)
ans = -1;
return ans;
}
int main()
{
memset(IsWall, true, sizeof(IsWall));
int qCnt;
scanf("%d%d%d", &TotRow, &TotCol, &qCnt);
for (int row = 1; row <= TotRow; row++)
for (int col = 1; col <= TotCol; col++)
{
int x;
scanf("%d", &x);
IsWall[row][col] = !x;
}
BuildG();
BuildS();
while (qCnt--)
{
scanf("%d%d%d%d%d%d", &StEmpRow, &StEmpCol, &StComRow, &StComCol, &TarComRow, &TarComCol);
printf("%d
", GetAns());
}
return 0;
}