Curling 2.0(dfs)

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 8795		Accepted: 3692

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

题意：给出一个w*h的矩阵，其中0代表可走区域，1代表石头，2代表起点（也属于可走区域），3代表终点（不可走区域），问冰壶从起点到终点最少走几步，但是这里的一步不是一个方格，
      而是每改变一次方向步数加1，因为冰壶移动的原则是：一旦选定一个方向就一直往前走，直到遇到石头或到达终点停止，遇到石头时冰壶改变方向继续直走；当冰壶遇到石头时，石头要由1变为0，
      递归之后别忘了再把这个状态改回来；注意如果冰壶只走了一步就遇到石头的话这个方向是不能走的。

      最后找出所有的步数之后比较出一个最短的就是了；

//可以从起点开始枚举方向和步数，冰壶一下可以走几步到达石头；

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 using namespace std;

 int w,h,map[][];
 int ans;
 int dir[][] = {{,},{,-},{-,},{,}};
 int minstep;

 int dfs(int sx,int sy,int step)
 {
     if(step > )
         return step;
     for(int i = ; i < ; i++)//枚举4个方向
     {
         for(int k = ; k < ; k++)//枚举走的步数
         {
             int tx = sx+dir[i][]*k;
             int ty = sy+dir[i][]*k;
             if(tx >=  && tx <= h && ty >=  && ty <= w)
             {
                 if(map[tx][ty] == )
                     return step+;//走到终点，返回
                 else if(map[tx][ty] == )
                 {
                     if(k == )
                         break;//如果只走一步遇到墙，不符合，跳出循环，走下一个方向
                     int x = sx+dir[i][]*(k-);
                     int y = sy+dir[i][]*(k-);//找到遇到墙之前一格的静止状态；
                     map[tx][ty] = ;//该墙标记为0；
                     minstep = min(minstep,dfs(x,y,step+));//从该静止状态起继续递归，并记录较小步数
                     map[tx][ty] = ;//将之前标记为0的墙重新修改回来；
                     break;//break不能忘记，因为按第i方向遇到第一个墙以后就改变方向了，不能继续直走；
                 }
             }
             else
                 break;
         }
     }
     return minstep;
 }
 int main()
 {
     int sx,sy;
     while(~scanf("%d %d",&w,&h))
     {
         if(w ==  && h == )
             break;
         for(int i = ; i <= h; i++)
             for(int j = ; j <= w; j++)
             {
                 scanf("%d",&map[i][j]);
                 if(map[i][j] == )
                 {
                      sx = i;
                      sy = j;
                      map[i][j] = ;
                 }
             }
         minstep = ;
         int ans = dfs(sx,sy,);
         if(ans > )
             printf("-1\n");
          else printf("%d\n",ans);

     }
     return ;
 }

//也可以从起点一个格一个格的走，当下一个格不是石头的时候按原来的方向继续走，当下一个格是石头的时候再枚举四个方向步数加1继续走；

 #include<stdio.h>
 #include<string.h>
 int dir[][] = {{,},{-,},{,},{,-}};
 int map[][];
 int w,h,sx,sy,ex,ey;
 int ans;
 void dfs(int x, int y,int d,int step)
 {
     if(step >  || map[x][y] == -)
         return;
     if(x == ex && y == ey)
     {
         if(ans == - || ans > step)
             ans = step;
         return;
     }
     if(map[x+dir[d][]][y+dir[d][]] != )
     {
         dfs(x+dir[d][],y+dir[d][],d,step);
         return;
     }
     if(map[x+dir[d][]][y+dir[d][]] == )
     {
         map[x+dir[d][]][y+dir[d][]] = ;
         for(int i = ; i < ; i++)
         {
             int xx = x+dir[i][];
             int yy = y+dir[i][];
             if(map[xx][yy] != )
                 dfs(xx,yy,i,step+);
         }
         map[x+dir[d][]][y+dir[d][]] = ;
     }
 }
 int main()
 {
     while(~scanf("%d %d",&w,&h))
     {
         if(w ==  && h == )
             break;
         memset(map,-,sizeof(map));
         for(int i = ; i <= h; i++)
         {
             for(int j = ; j <= w; j++)
             {
                 scanf("%d",&map[i][j]);
                 if(map[i][j] == )
                 {
                     sx = i;
                     sy = j;
                 }
                 if(map[i][j] == )
                 {
                     ex = i;
                     ey = j;
                 }
             }
         }
         ans = -;
         for(int i = ; i < ; i++)
         {
             int tx = sx+dir[i][];
             int ty = sy+dir[i][];
             if(map[tx][ty] != - && map[tx][ty] != )
                 dfs(tx,ty,i,);
         }
         printf("%d\n",ans);
     }
     return ;

 }