HDU_1175 连连看（BFS）

题目请点我
题解：
题目的意思就是针对当前的残局，输入多组检测看是否能消去。对于每组消去的规则是连线不能超过两折。这道题可以用BFS，也可以用DFS。但是觉得BFS要简单一些，如果用DFS的话注意减枝。BFS的话最先找到的是最短的路径，但是可行解不一定是最短路径，所以节点放入队列时的条件要有所修改，之前的visit数组保存的是是否访问过当前节点，那现在到达一个节点的状态有很多，所以visit数组的定义要做出改变，可以表示访问i,j时的转折次数。这是这道题能用来求可行解的关键。另外只有转折数小于等于当前转折次数的才能放入，因为进入一个点转折数等于是没问题的，而且可能换一个方向就能通过了。
WA了很多次，自己太急躁了，应该多想几组样例试一下的，要锻炼自己想样例的习惯。
代码实现：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <queue>
#include <limits.h>
#define MAX 1010

using namespace std;

//节点状态
struct node{
    int x,y;
    int dis;
    int times;
};
int N,M;
int times;
int x1,y1,x2,y2;
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
//访问i,j时的转折次数
int visit[MAX][MAX];
int grid[MAX][MAX];
bool bfs();
int main()
{
    while( scanf("%d%d",&N,&M) ){
        if( N == 0 && M == 0 ){
            break;
        }
        memset(grid,0,sizeof(grid));
        for( int i = 1; i <= N; i++ ){
            for( int j = 1; j <= M; j++ ){
                scanf("%d",&grid[i][j]);
            }
        }
        scanf("%d",&times);
        while( times-- ){
            //每次都要初始化
            for( int i = 1; i <= N; i++ ){
                for( int j = 1; j <= M; j++ ){
                    visit[i][j] = INT_MAX;
                }
            }
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            if( bfs() ){
                printf("YES\n");
//                grid[x1][y1] = 0;
//                grid[x2][y2] = 0;
            }
            else{
                printf("NO\n");
            }
        }
    }
    return 0;
}

bool bfs(){
    //不符合情况直接返回
    if( grid[x1][y1] != grid[x2][y2] ){
        return false;
    }
    else if( grid[x1][y1] == 0 || (x1 == x2 && y1 == y2) ){
        return false;
    }
    //起点放入，转折次数为0，初始方向定义为-1
    node a;
    a.x = x1;
    a.y = y1;
    a.dis = -1;
    a.times = 0;
    queue<node> Q;
    Q.push(a);
    while( !Q.empty() ){
        node tmp = Q.front();
        Q.pop();
        if( tmp.x == x2 && tmp.y == y2 ){
            return true;
        }
        for( int i = 0; i < 4; i++ ){
            int nx = dx[i]+tmp.x;
            int ny = dy[i]+tmp.y;
            //这里的判断条件失误让自己wa了很多次，最开始写成了grid[nx][ny]==grid[x2][y2]，死活没绕过来
            if( nx >= 1 && nx <= N && ny >= 1 && ny <= M && (grid[nx][ny] == 0 || (nx == x2 && ny == y2)) ){
                node in;
                in.x = nx;
                in.y = ny;
                in.dis = i;
                in.times = tmp.times;
                //方向不同转折数++
                if( tmp.dis != -1 && in.dis != tmp.dis ){
                    in.times++;
                }
                //只有转折数小于等于（注意一定要等于）当前转折次数的才能放入，并且不能超过2
                if( in.times <= 2 && visit[nx][ny] >= in.times ){
                    visit[nx][ny] = in.times;
                    Q.push(in);
                }
            }
        }
    }
    return false;
}