hdu 1010 奇偶剪枝

Tempter of the Bone

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 122827    Accepted Submission(s): 33201

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
  
  

题意：就是给你一个矩阵 要你从S点开始走到D点只能花费t时间问你可不可以走到，可以就YES否则NO；

思路 ：这个题目不能采用单纯的dfs否则会超时，一定要找到剪枝的条件，唯一一定要剪得就是 可行性剪枝，

列  入 

010101

101010

010101

这个三行六列的矩阵，偶数单元格用0表示，奇数单元格用1表示，假如要你从   （1 1）走到（3,6）要你花费7步可以走的到吗；答案是不可能走的到的，为什么呢；

每走一步都是跳到与本身相反的格子上，0--1，1--0；所以你开始本来是（0，0）=0；走到（3,6）=0；一定是要偶数步才可以，所以这就有了我们的奇偶剪枝了；

我们把当前单元格的 0或1加上终点的0或1%2如果等于还剩下多少步可以走（t-sum）%2 他们如果相等则可能到，如果不等则不可能到，不等就直接返回不用继续搜下去了；

下面根据我上面的解释看代码吧；

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int xx,yy,zx,zy;
int n,m,t,vis[10][10];
int dx[4]={-1,0,1,0};
int dy[4]={0,-1,0,1};
char map[10][10];
int map1[10][10];
int dfs(int x,int y,int sum)
{
    int i,xx,yy;
    int mindis=abs(x-zx)+abs(y-zy);
    if((map1[x][y]+map1[zx][zy])%2!=(t-sum)%2)
        return 0;
    if(x==zx&&y==zy)
    {
       if(sum==t)
               return 1;
        else
               return 0;
    }
    for(i=0;i<4;i++)
    {
        xx=x+dx[i];
        yy=y+dy[i];
        if(xx>0&&xx<=n&&yy>0&&yy<=m&&!vis[xx][yy]&&map[xx][yy]!='X')
        {
            vis[xx][yy]=1;
           if(dfs(xx,yy,sum+1)) return 1;
            vis[xx][yy]=0;
        }
    }
    return 0;
}
void solve()
{   for(int i=1;i<=n;i++)
      for(int j=1;j<=m;j++)
        if((i+j)%2==0) map1[i][j]=0;
        else map1[i][j]=1;
    memset(vis, 0, sizeof(vis));
        vis[xx][yy] = 1;
        if(dfs(xx, yy, 0))
           printf("YES\n");
        else
           printf("NO\n");
}
int main()
{
    int i,j;
    while(~scanf("%d%d%d",&n,&m,&t))
    {
        if(n==0&&m==0&&t==0)
            break;
            getchar();
      for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
             {
               scanf("%c",&map[i][j]);
                if(map[i][j]=='S')
                {
                    xx=i,yy=j;
                }
                if(map[i][j]=='D') zx=i,zy=j;
             }
             getchar();
        }
      solve();
    }
    return 0;
}