POJ 3009 深搜+回溯

Curling 2.0

Time Limit: 1000MS

Memory Limit: 65536KB

64bit IO Format: %lld & %llu

Submit Status

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

   坑爹的英语题，题目还这么长，对于英语不好的来说，做起来真的有点坑，读题用了将近一个小时才弄明白题意。
   题意:就是求从2到3所要走的最小的步数。
   2为起点，走到3，0为路，1为墙。
   如果遇到0，则继续走，直到出边界或者是遇到不为0的数停止。如果出边界的话，这一步走的没有意义，不做讨论，继续for循环。如果遇到1的话，则把1变成0，停留在这一点的前一个点，所以这里要注意减去走的方向对应的值(如果不太明白的话看代码，回溯那一部分)，注意还要有回溯。如果遇到的是3，则到达终点，记录此时的步数，继续查找，判断是不是有更少的步数。
   如果遇到1，分两种情况讨论:1.如果和这一步的起点紧挨着，则不能走，因为起点和为1的点中间要有缓冲，即为0的点，如图:
此时的时候不能走，因为起点的旁边都是墙，
如果是这种情况往右走的话

2的右边有一个0作为缓冲，则可以走。

还有一点一定要注意，输入是先列后行,好久没做过题了，结果一直死在这里

如果上述不太明白的话就看代码吧，里面有注释

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>

#define maxx 0x3f3f3ff

using namespace std;

int map[22][22];
int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int step;
int n,m, minn;
int sx, sy, ex, ey;

void Init()
{
    step = 0;
    minn = maxx;
    for(int i = 0; i < m; i ++)
    {
        for(int j = 0; j < n; j ++)
        {
            scanf("%d", &map[i][j]);
            //起点
            if(map[i][j] == 2)
            {
                sx = i;
                sy = j;
                //把起点置0，因为遇到2和遇到0的结果相同,都可以直接穿过
                map[i][j] = 0;
            }
            //终点
            if(map[i][j] == 3)
            {
                ex = i;
                ey = j;
            }
        }
    }
}

bool judge(int x, int y)
{
    if(x < 0 || x >= m || y < 0 || y >= n)
        return false;
    return true;
}

void dfs(int x, int y, int step)
{
    //题目要求最大10步，如果超过的话，果断换条路继续走
    //因为step从0开始的，所以step等于10也不可以
    //如果超过当前的最小步数的话，也停止前进
    if(step >= 10 || step > minn)
        return;

    for(int i = 0; i < 4; i ++)
    {
        int tx = x + dir[i][0];
        int ty = y + dir[i][1];

        //如果越界，不能走
        if(!judge(tx, ty))
            continue;

        //如果紧挨着的点等于1，不能走
        if(map[tx][ty] == 1)
            continue;

        if(map[tx][ty] == 3)
        {
            if(step + 1 < minn)
                minn = step + 1;
            //直接终止，进行下一次循环
            return;
        }

        bool flag = false;
        while(true)
        {
            tx += dir[i][0];
            ty += dir[i][1];
            if(judge(tx, ty))
            {
                //没有越界，有三种情况，下一步是0,1，或者是3。
                //0的时候不需要讨论，继续往下走即可

                //1的时候直接终止
                if(map[tx][ty] == 1)
                    break;

                //3的时候是终点,比较取最小
                else if(map[tx][ty] == 3)
                {
                    if(step + 1 < minn)
                        minn = step + 1;
                    //直接终止，进行下一次循环
                    return;
                }
            }
            else //出边界
            {
                flag = true;
                break;
            }
        }

        if(flag == true)
            continue;

        map[tx][ty] = 0;
        step += 1;
        //不要忘了减，因为碰到墙以后停留的是墙所在点的前一个位置
        dfs(tx - dir[i][0], ty - dir[i][1], step);
        step -= 1;
        map[tx][ty] = 1;
    }
}

int main()
{
//    freopen("in.txt", "r", stdin);
    while(~scanf("%d%d", &n, &m))
    {
        if(!n && !m)
            break;

        Init();

        dfs(sx, sy, step);

        if(minn == maxx)
            printf("-1\n");
        else
            printf("%d\n", minn);
    }
    return 0;
}