| Time Limit: 5000MS | Memory Limit: 65536K | |
| Total Submissions: 17042 | Accepted: 4065 |
Description
Holedox is a special snake, but its body is not very long. Its lair
is like a maze and can be imagined as a rectangle with n*m squares. Each
square is either a stone or a vacant place, and only vacant places
allow Holedox to move in. Using ordered pair of row and column number of
the lair, the square of exit located at (1,1).
Holedox's body, whose length is L, can be represented block by
block. And let B1(r1,c1) B2(r2,c2) .. BL(rL,cL) denote its L length
body, where Bi is adjacent to Bi+1 in the lair for 1 <= i <=L-1,
and B1 is its head, BL is its tail.
To move in the lair, Holedox chooses an adjacent vacant square of
its head, which is neither a stone nor occupied by its body. Then it
moves the head into the vacant square, and at the same time, each other
block of its body is moved into the square occupied by the corresponding
previous block.
For example, in the Figure 2, at the beginning the body of Holedox
can be represented as B1(4,1) B2(4,2) B3(3,2)B4(3,1). During the next
step, observing that B1'(5,1) is the only square that the head can be
moved into, Holedox moves its head into B1'(5,1), then moves B2 into B1,
B3 into B2, and B4 into B3. Thus after one step, the body of Holedox
locates in B1(5,1)B2(4,1)B3(4,2) B4(3,2) (see the Figure 3).
Given the map of the lair and the original location of each block of
Holedox's body, your task is to write a program to tell the minimal
number of steps that Holedox has to take to move its head to reach the
square of exit (1,1).
Input
input consists of several test cases. The first line of each case
contains three integers n, m (1<=n, m<=20) and L (2<=L<=8),
representing the number of rows in the lair, the number of columns in
the lair and the body length of Holedox, respectively. The next L lines
contain a pair of row and column number each, indicating the original
position of each block of Holedox's body, from B1(r1,c1) to BL(rL,cL)
orderly, where 1<=ri<=n, and 1<=ci<=m,1<=i<=L. The
next line contains an integer K, representing the number of squares of
stones in the lair. The following K lines contain a pair of row and
column number each, indicating the location of each square of stone.
Then a blank line follows to separate the cases.
The input is terminated by a line with three zeros.
Note: Bi is always adjacent to Bi+1 (1<=i<=L-1) and exit square (1,1) will never be a stone.
Output
each test case output one line containing the test case number followed
by the minimal number of steps Holedox has to take. "-1" means no
solution for that case.
Sample Input
5 6 4
4 1
4 2
3 2
3 1
3
2 3
3 3
3 4 4 4 4
2 3
1 3
1 4
2 4
4 2 1
2 2
3 4
4 2 0 0 0
Sample Output
Case 1: 9
Case 2: -1
Hint
Source
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
int N,M,L,K,all;
struct xy{int x,y;}P[];
struct node{int x,y,bs,has;};
bool vis[][][<<];
bool sto[][];
int fx[][]={-,,,,,-,,};
int ldx[]={,,,};
bool check(node t,int dx,int dy)
{
int x=t.x,y=t.y;
for(int i=;i<=L;++i)
{
int tt=;
if(t.has&) tt+=;t.has>>=;
if(t.has&) tt+=;t.has>>=;
x=x+fx[tt][];
y=y+fx[tt][];
if(x==dx&&y==dy) return ;
}
return ;
}
void bfs(node st)
{
memset(vis,,sizeof(vis));
queue<node>q;
q.push(st);
while(!q.empty()){
node t=q.front();q.pop();
if(vis[t.x][t.y][t.has]) continue;
vis[t.x][t.y][t.has]=;
if(t.x==&&t.y==){cout<<t.bs<<endl;return;}
for(int i=;i<;++i)
{
node _t=t;
int dx=_t.x+fx[i][];
int dy=_t.y+fx[i][];
if(dx<||dy<||dx>N||dy>M||sto[dx][dy]||!check(_t,dx,dy)) continue;
int has=(_t.has<<)&(all)|(ldx[i]);
_t.has=has;
_t.bs++;
_t.x=dx;
_t.y=dy;
if(vis[dx][dy][has]) continue;
q.push(_t);
}
}
puts("-1");
}
int main()
{
int i,j,k=;
while(cin>>N>>M>>L){
if(N==&&M==&&L==) break;
memset(sto,,sizeof(sto));
for(i=;i<=L;++i) scanf("%d%d",&P[i].x,&P[i].y);
scanf("%d",&K);
for(i=;i<=K;++i)
{
int o,p;
scanf("%d%d",&o,&p);
sto[o][p]=;
}
printf("Case %d: ",++k);
all=(<<((L-)*))-;
node st;
st.x=P[].x;
st.y=P[].y;
st.bs=;
st.has=;
for(i=;i<=L;++i)
{
for(j=;j<;++j)
{
int dx=P[i-].x+fx[j][];
int dy=P[i-].y+fx[j][];
if(dx==P[i].x&&dy==P[i].y){
st.has=st.has|(j<<((i-)*));
}
}
}
bfs(st);
}
return ;
}