Problem 1009

简单题意：判断是否能完成连连看，规则与我们玩的规则差不多，但不能从外围连线，这与传统的玩法有区别

解题思路：这道题将BFS做一点小小的变形，即每次让一个方向的可能点全部入对列，这样能够使得拐弯次数限制到最小，标记的变量要设四个方向，每次走过的点要标记两个方向，向前和向后，显然不可能再次走到这一点以相同的方向或者反过来。其他就和一般的BFS差不多了

此题虽然没做出来，可是大体题意跟思路已经掌握了，!

运行如下：

代码如下：

#include
#include
#include
#include
#define INF 0x7f7f7f7f
using namespace std;


int map[1005][1005], hash[4][1005][1005], dir[4][2]= { 1, 0, -1, 0, 0, 1, 0, -1 };


struct Node
{
    int x, y, type, ti, dir;
}info;


void gint( int &t )
{
    char c;
    while( c= getchar(), c< '0'|| c> '9' ) ;
    t= c- '0';
    while( c= getchar(), c>= '0'&& c<= '9' )
    {
        t= t* 10+ c- '0';
    }
}


bool BFS( int sx, int sy, int ex, int ey )
{
    queue< Node >q;
    memset( hash, 0, sizeof( hash ) );
    info.x= sx, info.y= sy, info.type= map[sx][sy], info.ti= 0, info.dir= -1;
    hash[0][sx][sy]= hash[1][sx][sy]= hash[2][sx][sy]= hash[3][sx][sy]= 1;
    q.push( info );
    while( !q.empty() )
    {
        Node pos= q.front();
        q.pop();
        if( pos.x== ex&& pos.y== ey )
        {
            return true;
        }
        for( int i= 0; i< 4; ++i )
        {
            int x= pos.x+ dir[i][0], y=pos.y+ dir[i][1], ti= pos.ti, d= pos.dir;
            while( ( map[x][y]== 0|| ( x== ex&& y== ey ) )&& !hash[i][x][y] )
            {
                int k= ( i== d|| d== -1 )? 0: 1;
                info.x= x, info.y= y, info.ti= ti+ k, info.dir= i;
                if( info.ti<= 2 )
                {
                    if( info.ti< 2|| ( info.ti== 2 && ( x== ex|| y== ey ) ) )
                    {
                        q.push( info );
                    }
                    hash[i][x][y]= 1;
                    if( i== 0|| i== 1 )
                    {
                        hash[!i][x][y]= 1;
                    }
                    else if( i== 2 )
                    {
                        hash[3][x][y]= 1;
                    }
                    else
                    {
                        hash[2][x][y]= 1;
                    }
                }
                x+= dir[i][0], y+= dir[i][1];
            }
        }
    }
    return false;
}


int main()
{
    int N, M;
    while( scanf( "%d %d", &N, &M ), N| M )
    {
        memset( map, 0x7f, sizeof( map ) );
        for( int i= 1; i<= N; ++i )
        {
            for( int j= 1; j<= M; ++j )
            {
                gint( map[i][j] );
            }
        }
        int q;
        scanf( "%d", &q );
        while( q-- )
        {
            int sx, sy, ex, ey;
            scanf( "%d %d %d %d", &sx, &sy, &ex, &ey );
            if( ( map[sx][sy]!= map[ex][ey] )|| map[sx][sy]== 0|| map[ex][ey]== 0|| ( sx== ex&& sy== ey ) )
            {
                puts( "NO" );
                continue;
            }
            printf( BFS( sx, sy, ex, ey )? "YES\n": "NO\n" );
        }
    }
    return 0;
}