Hduoj1010【深搜+剪枝】

/*Tempter of the Bone
Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 74147    Accepted Submission(s): 20296

Problem Description
The doggie found a bone in an ancient maze, which fascinated him a lot. However, when he picked it up, the maze began to shake, and the doggie 
could feel the ground sinking. He realized that the bone was a trap, and he tried desperately to get out of this maze.

The maze was a rectangle with sizes N by M. There was a door in the maze. At the beginning, the door was closed and it would open at the T-th 
second for a short period of time (less than 1 second). Therefore the doggie had to arrive at the door on exactly the T-th second. In every 
second, he could move one block to one of the upper, lower, left and right neighboring blocks. Once he entered a block, the ground of this
block would start to sink and disappear in the next second. He could not stay at one block for more than one second, nor could he move into 
a visited block. Can the poor doggie survive? Please help him.


Input
The input consists of multiple test cases. The first line of each test case contains three integers N, M, and T (1 < N, M < 7; 0 < T < 50), 
which denote the sizes of the maze and the time at which the door will open, respectively. The next N lines give the maze layout, with each
 line containing M characters. A character is one of the following:

'X': a block of wall, which the doggie cannot enter; 
'S': the start point of the doggie; 
'D': the Door; or
'.': an empty block.

The input is terminated with three 0's. This test case is not to be processed.


Output
For each test case, print in one line "YES" if the doggie can survive, or "NO" otherwise.


Sample Input
4 4 5
S.X.
..X.
..XD
....
3 4 5
S.X.
..X.
...D
0 0 0
 

Sample Output
NO
YES
 

Author
ZHANG, Zheng
 

Source
ZJCPC2004 
*/ 
#include<stdio.h>
#include<string.h>
#include<stdlib.h> 
int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, 1, -1}, vis[10][10], n, m, time, stack[110], num, x1, y1, ok;
char maze[10][10]; 
void dfs(int x, int y)
{
    if(num == time)
    {
        if(x == x1 && y == y1)//判断时间到了是否刚好是终点 
            ok = 1;
        return;
    }
    if(ok)return;//搜索停止条件 
    int dis = abs(time-num) - (abs(x-x1)+abs(y-y1));
    if(dis<0 || dis&1)   //剪枝关键处  首先剩余的最短距离不能大于剩余所能走的步数 
    return;              //其次两个相减之后的步数必定为偶数才能恰好走到终点 
    for(int d = 0 ; d < 4; d++)
    {
        int nx = x+dx[d], ny = y+dy[d];
        if(nx >= 0 && nx < n && ny >= 0 && ny < m && maze[nx][ny] != 'X')
        {
            
            num++;
            maze[nx][ny] = 'X'; //标记为访问过 
            dfs(nx, ny);
            maze[nx][ny] = '.';//回溯 
            num--;
        }
    }
}
int main()
{
    while(scanf("%d%d%d", &n, &m, &time) != EOF && (n||m||time))
    {
        int x, y;
        for(int i = 0; i < n; i++)
        {
            scanf("%s", maze[i]);
            if(strchr(maze[i], 'S'))
            {
                for(int j = 0; j < m; j++)
                {
                    if(maze[i][j] == 'S')//记录起点
                    {
                        x = i;
                        y = j;
                        break;
                    }
                } 
            }
            if(strchr(maze[i], 'D'))
            {
                for(int j = 0; j < m; j++)
                {
                    if(maze[i][j] == 'D')//记录终点
                    {
                        x1 = i;
                        y1 = j;
                        break;
                    }
                } 
            }
        }
        ok = 0;
        num = 0;
        maze[x][y] = 'X';//终点标记为墙
        dfs(x,y);
        if(ok)
        printf("YES\n");
        else
        printf("NO\n");
    }
    return 0;
}

题意：给出一个迷宫，规定每个点只能走一次，每走一个消耗一个单位时间，求是否能从起点到终点恰好用t秒。

思路：深搜加剪枝，每走一格记录时间，每次走完一格就判断是否能走到终点，当所用的时间已经达到t是判断该点是不是终点，若是说明能输出YES否则NO。

体会：其中最难的就是剪枝操作，两个判断条件缺一不可，少一个都会超时，要想到该剪枝操作有一定难度。