Holedox Moving

http://162.105.81.212/JudgeOnline/problem?id=1324

Description

 

During winter, the most hungry and severe time, Holedox sleeps in its lair. When spring comes, Holedox wakes up, moves to the exit of its lair, comes out, and begins its new life.
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

 

The 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

 

For 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

In the above sample case, the head of Holedox can follows (4,1)->(5,1)->(5,2)->(5,3)->(4,3)->(4,2)->(4,1)->(3,1)->(2,1)->(1,1) to reach the square of exit with minimal number of step, which is nine.

Source

Beijing 2002

这道题从WA到RE ， 再到MLE , 再到TLE, 提交了十多次；

WA 是以为裸的广搜就可以了；

RE是对可能的搜索到状态空间数量级判断错误 ， 数组开小了；

MLE是内存超了；

TLE是广搜没有剪枝(广搜好像从来没剪过枝)；

找了份 解题报告 ，看了如何剪枝，花了两小时AC了；

剪枝的思想很数学 ， 觉得原理和以前数学上的不等式的放缩法很像，先去除一些限制条件，找到它的下限（上限），

再加上一些限制条件找到找到它的上限（下限），如果上限等于下限，答案就就找到了，否则再进行搜索。

想起以前做过一道能否在规定时间t内找到出口的题目，出口与起点的横纵坐标之差的绝对值之和是否小于t,否则无解；

这种剪枝方式也属于这一类。这种剪枝方法适合在搜索过程中有一定限制条件的题目.

#include <iostream> #include <queue> using namespace std ; struct Position { int i , j ; }; int n , m , l , low , high , step[4][2] = {​{-1 , 0} , {0 , 1} , {1 , 0} , {0 , -1}} ; bool map[21][21] , visited[21][21][16400] , stone[21][21] ; Position start[8] , next[8] ; int CoorToState (Position *P) { int i , j , k , res = 0 ; for (j = i = 1 ; i < l ; i ++ , j <<= 2) { for (k = 0 ; k < 4 ; k ++) if (P[i - 1].i + step[k][0] == P[i].i && P[i - 1].j + step[k][1] == P[i].j) break ; res += k * j ; } return res ; } void StateToCoor (Position *p , int i , int j , int state) { p[0].i = i , p[0].j = j ; for (i = 1 ; i < l ; i ++ , state >>= 2) { p[i].i = p[i - 1].i + step[state % 4][0] ; p[i].j = p[i - 1].j + step[state % 4][1] ; } } void Readin () { int i , s , r , c ; for (i = 0 ; i < l ; i ++) scanf ("%d%d" , &start[i].i , &start[i].j) ; scanf ("%d" , &s) ; memset (map , false , sizeof (map)) ; memset (visited , false , sizeof (visited)) ; while (s --) { scanf ("%d%d" , &r , &c) ; map[r][c] = true ; } } int BFS_Head () { queue <int> Q ; int i , ii , jj , j , res , k ; Q.push(1) , Q.push(1) , Q.push(0) ; stone[1][1] = true ; if (1 == start[0].i && 1 == start[0].j) return 0 ; while (!Q.empty()) { i = Q.front () , Q.pop () ; j = Q.front () , Q.pop () ; res = Q.front () , Q.pop () ; for (k = 0 ; k < 4 ; k ++) { ii = i + step[k][0] ; jj = j + step[k][1] ; if (ii < 1 || jj < 1 || ii > n || jj > m || stone[ii][jj]) continue ; if (ii == start[0].i && jj == start[0].j) return res + 1 ; stone[ii][jj] = true ; Q.push (ii) , Q.push (jj) , Q.push (res + 1) ; } } return -1 ; } int BFS_Snake () { int i , ii , j , jj , k , kk , state , res ; Position cur[8] , next[8] ; queue <int> Q ; state = CoorToState (start) ; visited[start[0].i][start[0].j][state] = true ; Q.push (start[0].i) , Q.push (start[0].j) , Q.push (0) ; Q.push (state) ; while (!Q.empty()) { i = Q.front () , Q.pop () ; j = Q.front () , Q.pop() ; res = Q.front () , Q.pop() ; state = Q.front () , Q.pop () ; StateToCoor (cur , i , j , state) ; if (res == high) return -1 ; for (k = 0 ; k < 4 ; k ++) { ii = i + step[k][0] ; jj = j + step[k][1] ; if (ii < 1 || jj < 1 || ii > n || jj > m || map[ii][jj]) continue ; for (kk = 0 ; kk < l ; kk ++) if (ii == cur[kk].i && jj == cur[kk].j) break ; if (kk < l) continue ; for (kk = 1 ; kk < l ; kk ++) next[kk] = cur[kk - 1] ; next[0].i = ii ; next[0].j = jj ; state = CoorToState (next) ; if (visited[ii][jj][state]) continue ; visited[ii][jj][state] = true ; if (ii == 1 && jj == 1) return res + 1 ; Q.push (ii) , Q.push (jj) , Q.push (res + 1) , Q.push (state) ; } } return -1 ; } void GetRange () { memcpy (stone , map , sizeof (map)) ; low = BFS_Head () ; memcpy (stone , map , sizeof (map)) ; for (int i = 1 ; i < l ; i ++) stone[start[i].i][start[i].j] = true ; high = BFS_Head () ; if (high < 0) high = 0x7fffffff ; } int main () { int T = 1 ; while (scanf ("%d%d%d" , &n , &m , &l) , n , m , l) { Readin () ; printf ("Case %d: " , T ++) ; GetRange () ; if (low < 0) printf ("-1/n") ; else if (low == high) printf ("%d/n" , low) ; else printf ("%d/n" , BFS_Snake ()) ; } return 0 ; }