POJ 3009  迭代加深搜索

Curling 2.0

Description

On Planet MM-21, after their Olympic games this year, curling is getting popular. But the rules are somewhat different from ours. The game is played on an ice game board on which a square mesh is marked. They use only a single stone. The purpose of the game is to lead the stone from the start to the goal with the minimum number of moves.

Fig. 1 shows an example of a game board. Some squares may be occupied with blocks. There are two special squares namely the start and the goal, which are not occupied with blocks. (These two squares are distinct.) Once the stone begins to move, it will proceed until it hits a block. In order to bring the stone to the goal, you may have to stop the stone by hitting it against a block, and throw again.

Fig. 1: Example of board (S: start, G: goal)

The movement of the stone obeys the following rules:

• At the beginning, the stone stands still at the start square.
• The movements of the stone are restricted to x and y directions. Diagonal moves are prohibited.
• When the stone stands still, you can make it moving by throwing it. You may throw it to any direction unless it is blocked immediately(Fig. 2(a)).
• Once thrown, the stone keeps moving to the same direction until one of the following occurs:
  • The stone hits a block (Fig. 2(b), (c)).
    • The stone stops at the square next to the block it hit.
    • The block disappears.
  • The stone gets out of the board.
    • The game ends in failure.
  • The stone reaches the goal square.
    • The stone stops there and the game ends in success.
• You cannot throw the stone more than 10 times in a game. If the stone does not reach the goal in 10 moves, the game ends in failure.

Fig. 2: Stone movements

Under the rules, we would like to know whether the stone at the start can reach the goal and, if yes, the minimum number of moves required.

With the initial configuration shown in Fig. 1, 4 moves are required to bring the stone from the start to the goal. The route is shown in Fig. 3(a). Notice when the stone reaches the goal, the board configuration has changed as in Fig. 3(b).

Fig. 3: The solution for Fig. D-1 and the final board configuration

Input

The input is a sequence of datasets. The end of the input is indicated by a line containing two zeros separated by a space. The number of datasets never exceeds 100.

Each dataset is formatted as follows.

the width(=w) and the height(=h) of the board 
First row of the board 
... 
h-th row of the board

The width and the height of the board satisfy: 2 <= w <= 20, 1 <= h <= 20.

Each line consists of w decimal numbers delimited by a space. The number describes the status of the corresponding square.

0	vacant square
1	block
2	start position
3	goal position

The dataset for Fig. D-1 is as follows:

6 6 
1 0 0 2 1 0 
1 1 0 0 0 0 
0 0 0 0 0 3 
0 0 0 0 0 0 
1 0 0 0 0 1 
0 1 1 1 1 1

Output

For each dataset, print a line having a decimal integer indicating the minimum number of moves along a route from the start to the goal. If there are no such routes, print -1 instead. Each line should not have any character other than this number.

Sample Input

2 1
3 2
6 6
1 0 0 2 1 0
1 1 0 0 0 0
0 0 0 0 0 3
0 0 0 0 0 0
1 0 0 0 0 1
0 1 1 1 1 1
6 1
1 1 2 1 1 3
6 1
1 0 2 1 1 3
12 1
2 0 1 1 1 1 1 1 1 1 1 3
13 1
2 0 1 1 1 1 1 1 1 1 1 1 3
0 0

Sample Output

1
4
-1
4
10
-1

题意：已知起点和终点，求石子从起点到达终点的最短路，如果无法到达，则输出-1。石子移动的具体规则如下：   1、开始时，石子在起点s处   2、运动方向可以是水平或垂直的，不能斜方向运动   3、最开始的时候，你可以将石子向上下左右任意一个方向抛，如果与它相邻的点是障碍物的话除外   4、一旦石子开始运动，有三种可能：      a、遇到障碍物，石子会停在障碍物的前一格，障碍物会消失      b、如果出界，游戏失败      c、到达终点，游戏结束并成功   5、如果移动的次数超过10次，将认为游戏是失败的思路：以前的最短路都是一格一格地扩展的，这个直接直线扩展，bfs，dfs，迭代加深都可以解，本来想用bfs，然后发现bfs难处理方向，就改用dfs了，但也没AC，第二天用迭代加深直接AC了，很考察对方法的选择，dfs不适合求最短路，bfs又难以处理方向，最好的做法当然是迭代加深了，即每次限制搜索的步数，并逐步增加步数上限。后来想到按类似8数码问题bfs+hash也很简单的

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

const int maxn=30;
const int INF=(1<<28);
const int STOP=-1;  //方向状态为静止

int m,n;
int map[maxn][maxn];
int sx,sy;   //起点
int ans;
bool flag;
int dx[]={0,0,-1,1};  //4个方向
int dy[]={-1,1,0,0};

void dfs(int x,int y,int dir,int nowstep,int steplimit)  //nowstep为当前步数，steplimit为迭代加深搜索的限制步数
{
    if(flag) return;
    if(nowstep>steplimit) return;
    if(map[x][y]==3){
        flag=1;
        return;
    }
    if(dir==STOP){   //方向为静止时
        for(int i=0;i<4;i++){
            int nx=x+dx[i],ny=y+dy[i];
            if(map[nx][ny]==-1||map[nx][ny]==1) continue;
            dfs(nx,ny,i,nowstep+1,steplimit);
        }
        return;
    }
    int nx=x+dx[dir],ny=y+dy[dir];  //方向为非静止时
    if(map[nx][ny]==-1) return;
    if(map[nx][ny]==1){  //下一步为墙时
        map[nx][ny]=0;
        dfs(x,y,STOP,nowstep,steplimit);
        map[nx][ny]=1;
    }
    else dfs(nx,ny,dir,nowstep,steplimit); //下一步不是墙时
}

int main()
{
    while(cin>>m>>n,m||n){
        memset(map,-1,sizeof(map));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                scanf("%d",&map[i][j]);
                if(map[i][j]==2){
                    sx=i,sy=j;
                }
            }
        }
        flag=0;
        for(int i=1;i<=10;i++){ //迭代加深搜索
            dfs(sx,sy,STOP,0,i);
            if(flag){
                ans=i;
                break;
            }
        }
        if(flag) cout<<ans<<endl;
        else cout<<-1<<endl;
    }
    return 0;
}

poj3009_迭代加深搜索