hdu 1175 连连看

基础搜索

中文题意不解释，这题没看sample直接看完题目就打，发现不对，才看到数据可能各种无聊的坑

1.可能出现相同位置的点，直接判NO

2.两个点中，可能一个点是空白点，直接判NO

3.两个点的值不同，直接判NO

剩下的情况才是值得去搜索的，即两点值相同且都不是空白

同BFS去搜

定义状态，包括信息有

1.x，y即该点在盘中的坐标

2.c，从起点走到这里，转弯次数，为0,1,2。  3或以上的已经不行了，直接抛弃掉

3.n，方向，从什么方向来到这个点，有0,1,2,3表示上，左，右，下，这样排序方便计算

然后每次从当前点往4个方向搜索，并且开一个标记数组来标记哪些状态在队列中，inq[x][y][c][n]，耗时6500ms

将标记数组压缩为三维，inq[x][y][n]，耗时3700ms，还是比较糟糕

#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
#define N 1010
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))

//对应上左右下四个方向的变化，这样排列4个方向是为了方便计算
const int dx[4] = {-1,0,0,1};
const int dy[4] = {0,-1,1,0};

int row,col,query;
int map[N][N];
bool inq[N][N][4];
struct state{
    int x,y; //点的坐标，可以写成编号，但是坐标更好
    int c; //转弯次数
    int n;  //从哪个方向来的
};
typedef struct state state;

int bfs(int x1 ,int y1 ,int x2 ,int y2)
{
    queue<state>q;
    state temp;
    while(!q.empty()) q.pop();
    memset(inq,false,sizeof(inq));
    temp.x = x1;  temp.y = y1;
    temp.c = 0;   temp.n = -1; //初始化状态没有方向用-1表示
    q.push(temp);
    while(!q.empty())
    {
        int x,y,c,n;
        temp = q.front();
        q.pop();

        x = temp.x;  y = temp.y;
        c = temp.c;  n = temp.n;
        inq[x][y][n] = false;

        for(int k=0; k<4; k++) //扫描4个方向
        {
            int cc,nn;
            int xx = x + dx[k];
            int yy = y + dy[k];
            
            if(n == k) continue;//走回原来的格子 
            if(n == -1){//起始状态
                cc = 0; //转弯数不用增加
                nn = 3 - k; 
            }
            else if(n + k == 3){//说明方向没有改变
                cc = c; //那么转弯次数不变
                nn = n;  //方向当然不变
            }
            else{//既不是起始状态也不是沿相同方向
                cc = c + 1;
                nn = 3 - k;
            }

            if( xx < 1 || xx > row || yy < 1 || yy > col) continue; //越过了迷宫，放弃
            if( cc > 2) continue;//转弯次数大于2，放弃
            if(xx == x2 && yy == y2) return 1;//找到了目标
            if(map[xx][yy]) continue; //不是空白格子
            if(inq[xx][yy][nn]) continue;
            temp.x = xx;  temp.y = yy;
            temp.c = cc;  temp.n = nn;
            q.push(temp);
            inq[xx][yy][nn] = true;
        }
    }
    return 0;
}

int main()
{
    while(scanf("%d%d",&row,&col)!=EOF)
    {
        if(!row && !col) break;
        for(int i=1; i<=row; i++)
            for(int j=1; j<=col; j++)
                scanf("%d",&map[i][j]);

        int x1,y1,x2,y2;
        scanf("%d",&query);
        for(int i=0; i<query; i++)
        {
            int ok;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            if(x1 == x2 && y1 == y2)
                ok = 0;
            else if(map[x1][y1] != map[x2][y2] || !map[x1][y1] || !map[x2][y2])
                ok = 0;
            else
                ok = bfs(x1,y1,x2,y2);
        
            if(ok) printf("YES\n");
            else   printf("NO\n");
        }
    }
    return 0;
}