hdu 1175 DFS连连看

题意：中文题就不说了。

思路：DFS，关键是那个转折大于两次就不行的情况怎么深搜，可以枚举递归起始点的四个方向，如果在DFS中的方向K和递归中的不一样而且还满足深搜条件，那么转折次数就加一。

这道题WA了好长时间，最后在网上搜的测试数组，然后对比出了几个错误，终于艰难的AC啦~  灰常爽！

AC代码：

#include<iostream>
using namespace std;
int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
int map[1005][1005];
bool vis[1005][1005];
int sx,sy,ex,ey,n,m;
bool flag;
void dfs(int i,int j,int d,int ans)
{
  if(flag) return ;
  if(i==ex&&j==ey&&ans<=2) {flag=1;return ;}//如果搜到目标点并且转折数小于等于2 那么搜索成功
  if(ans>2) return ;
  for(int k=0;k<4;k++)
  {
    int x=i+dir[k][0];
    int y=j+dir[k][1];
    if(!vis[x][y]&&x>0&&x<=n&&y>0&&y<=m)
    {
      if(map[x][y]==0)
      {
        vis[x][y]=1;
        if(d==k) dfs(x,y,k,ans);//如果没有改变方向则继续搜
        else  dfs(x,y,k,ans+1);//改变了方向的话转折数加一继续搜
        vis[x][y]=0;
      }
      if(x==ex&&y==ey)//如果找到目标节点，再看当前搜索方向一不一致，不一致依然要转折数加一
      {
        if(d==k) dfs(x,y,k,ans);
        else dfs(x,y,k,ans+1);
      }
    }
  }
  return ;
}
int main()
{
  int N,d,h;
  //freopen ("F:\\out.txt", "r", stdin) ;
  //freopen ("F:\\我的输出数据.txt", "w", stdout) ;
	  int w=1;
  while(scanf("%d%d",&n,&m)!=EOF)
  {
 //   printf("第%d组测试数据\n",w++);
    if(n==0&&m==0) break;
    for(int i=1;i<=n;i++)
     for(int j=1;j<=m;j++)
     scanf("%d",&map[i][j]);
     memset(vis,0,sizeof(vis));
     scanf("%d",&N);
     //int g=1;
     while(N--)
     {
       scanf("%d%d%d%d",&sx,&sy,&ex,&ey);
       h=0;flag=0;//根据随机出来的数据找到的错误，这两个标记应该放在这里初始化，否则会出错。
       if(map[sx][sy]!=map[ex][ey]) {printf("NO\n");continue;}
       else if(map[sx][sy]==0||map[ex][ey]==0) {printf("NO\n");continue;}
       else
       {
         //printf("运行");
         for(d=0;d<4;d++)
         {
           int x=sx+dir[d][0];
           int y=sy+dir[d][1];
           if(x==ex&&y==ey)  {h=1;printf("YES\n");break;}
           if(map[x][y]==0&&x>=1&&x<=n&&y>=1&&y<=m)
           {
             dfs(x,y,d,0);
             if(flag)  
             {
             h=1;
             printf("YES\n");break;
             }
           }
         }
         if(!h) printf("NO\n");
       }
     }
  }
}

下面是网上的生成数据的代码：

/* THE PROGRAM IS MADE BY PYY */  
/*----------------------------------------------------------------------------// 
Copyright (c) 2011 panyanyany All rights reserved. 
 
URL   : http://acm.hdu.edu.cn/showproblem.php?pid=1175 
Name  : 1175 连连看 
 
Date  : Wednesday, August 17, 2011 
Time Stage : long , very long....... 
 
Result:  
 
Test Data:  
 
Review:  
可惜有了数据还是弄不明白原理，好笨啊～～～ 
//----------------------------------------------------------------------------*/  
/*----------------------------------------------------------------------------- 
1175 连连看 随机数据生成器 
**---------------------------------------------------------------------------*/  
  
#include <stdio.h>  
#include <conio.h>  
#include <string.h>  
#include <time.h>  
#include <stdlib.h>  
  
#define MAXSIZE 10009  
#define LIMIT   10      // 生成的图表都是 10*10 的规格的，方便人工跟踪找错  
// 这里也可以设得大点，或小点，我觉得10个比较合适  
  
#define getNotZeroRand(x) while (!((*x) = rand() % LIMIT)) ;  
#define getNumUpperThan(x, y) while ((*(x) = rand() % LIMIT) < y) ;  
#define getNumInRange(x, lower, upper) while ((*(x) = rand() % upper) < lower) ;  
  
int repeat[MAXSIZE] ;  
int map[MAXSIZE][MAXSIZE] ;  
  
int main ()  
{  
    //  freopen ("D:\\Computer Language\\C++\\Test\\in.txt", "r", stdin) ;  
    int i, j, k ;  
    int n, m, num, tmp, q ;  
    int x1, y1, x2, y2 ;  
  
    puts ("input data number : ") ; // 提示语言不能输入到文件中，所以要先写  
  
    // 文件重定向，把原来要输出到屏幕上的内容，输出到文件上去  
    freopen ("F:\\out.txt", "w", stdout) ;  
    scanf ("%d", &num) ;  
    srand (0) ; // 设置随机数种子，貌似不设也可以。。。。。。  
    // 当时只是想让产生的随机数更"随机"一点，其实反而不方便找错  
    // 固定的数据，可以经得起反复的查找  
  
    for (i = 0 ; i < num ; ++i)  
    {  
        // 生成 10 * 10 的数据量  
        // 用 getNumInRange 也可以，不过这个是先写的，也就没有去改了  
        getNumUpperThan (&n, 2) ;  
        getNumUpperThan (&m, 2) ;  
  
        // 想获得多少组数据，就输入多少，我10000条左右就能测出错误来了  
        // 当然，你得先有个标准的答案代码，利用这里的数据产生标准答案，  
        // 再和自己产生的答案对比，才有意义。  
        printf ("%d %d\n", n, m) ;  
  
        memset (repeat, 0, sizeof (repeat)) ;   // 用来计算数字的重复次数，  
        // 一张图里面的一个数字只能重复两次  
  
        for (j = 0 ; j < n ; ++j)  
        {  
            for (k = 0 ; k < m; ++k)  
            {  
                tmp = rand () % (n * m) ;  
                // 其实这个限制重复次数的循环有时候会很花时间的  
                // 但实际上好像影响不大，所以没有想去改进  
                while (repeat[tmp] >= 2)  
                    tmp = rand () % (n * m) ;  
                ++repeat[tmp] ;  
  
                // 这里，限定0的分布频率，为40%  
                // 也就是说，不管你输出多少数，总有40%的数是0  
                // 如果0太少，这样的数据是没有什么意义的  
                // 不过从我实验的情况来看，貌似0多点更能查检出错误来。。。。。  
                if ((n*m)/4 <= tmp)  
                    tmp = 0 ;  
  
                // 记录新鲜出炉的数，趁热，别凉了 :)  
                map[j][k] = tmp ;  
            }  
        }  
  
        //输出图表  
        for (j = 0 ; j < n ; ++j)  
        {  
            for (k = 0 ; k < m - 1; ++k)  
            {  
                printf ("%d ", map[j][k]) ;  
            }  
            printf ("%d\n", map[j][k]) ;  
        }  
  
        // 把询问次数限定在50以内。。。且不能为0  
        while (!(q = rand () % 50)) ;  
  
        printf ("%d\n", q) ;  
  
        for (j = 0 ; j < q ; ++j)  
        {  
            // 这里获得的数据要求 1 <= x < n + 1  
            getNumInRange (&x1, 1, n + 1) ;  
            getNumInRange (&y1, 1, m + 1) ;  
            getNumInRange (&x2, 1, n + 1) ;  
            getNumInRange (&y2, 1, m + 1) ;  
  
            printf ("%d %d %d %d\n", x1, y1, x2, y2) ;  
        }  
        // 刷新缓冲区，现在已经没什么作用了。  
        // 但刚开始的时候，这个程序有些错误，需要及时刷新来查看究竟是运行到哪了  
        fflush (stdout) ;  
    }  
    // 别忘了还要有结束的一行  
    printf ("0 0\n") ;  
    return 0 ;  
}  

先生成数据，然后找个正确的程序运行数据得出正确结果，在用自己的程序跑一下看下输出。我找到的这组数据，发现我程序的BUG

貌似题目数据有问题，两个非0的相同点，怎么能消去呢？囧了，但是也过了。 1 2 7 2-->发现我h=0 初始话的位置不对。后来发现flag=0;忘记写了真搓啊~

8 4
0 5 0 6
0 0 0 0
0 0 3 3
0 6 0 0
0 1 0 0
0 0 0 0
4 5 0 0
0 0 0 0
32
4 2 3 1
4 1 3 4
8 1 3 4
2 3 2 1
1 1 8 1
4 2 4 4
7 2 7 2
4 1 1 2
5 3 2 3
1 4 4 1
6 3 7 3
7 4 5 2
5 2 8 4
2 1 8 2
4 4 1 3
7 2 4 2
6 3 5 1
3 1 5 3
5 4 1 3
2 1 3 2
5 1 7 3
1 2 1 1
7 2 5 1
4 4 7 1
7 3 4 3
2 4 8 2
6 4 1 1
4 2 4 1
1 2 7 2
1 1 7 1
8 3 3 1
4 3 8 2