POJ 2049 Finding Nemo （网格中的BFS）

Finding Nemo

大意：

有一个迷宫，在迷宫中有墙与门有m道墙，每一道墙表示为(x,y,d,t），x,y表示墙的起始坐标d为0即向右t个单位，都是墙d为1即向上t个单位，都是墙有n道门，每一道门表示为(x,y,d)，x,y表示门的起始坐标d为0即向右一个单位表示门d为1即向上一个单位表示门再给出你起点的位置(f1,f2)，并保证这个点的位置不会再墙或者门中，为起点到(0,0)最少要穿过多少条门

思路：

将坐标系看成网格，在这里我以每个格子的左下点为基点，那么坐标对应网格
坐标(0,0)的网格为(1,1)
坐标(1,1)的网格为(2,2)
坐标(1,2)的网格为(2,3)
...
依次类推

我再定义X[i][j]代表网格(i,j)的上边的值
Y[i][j]代表网格(i,j)的右边的值
值分为三种，空地，墙，门

这里要注意的是要全部搜索完，因为要穿过最少的门，用优先队列搞定
还有当在迷宫外面时，直接输出0,

#include <map>
#include <stack>
#include <queue>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <limits.h>
#include <algorithm>
#define LL long long
#define min(a,b) (a>b?b:a)
#define max(a,b) (a>b?a:b)
#define eps 1e-9
#define INF 1 << 30
using namespace std;

#define Door 1
#define Wall INF

int x_max, y_max;
int X[210][210], Y[210][210];
int dis[210][210];
int dt[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

bool Border_Judge(int x, int y)
{
    if(x > 0 && x <= x_max && y > 0 && y <= y_max)
        return true;
    return false;
}

int Change(int x, int y, int i)
{
    if(i == 0)
        return Y[x-1][y];
    if(i == 1)
        return Y[x][y];
    if(i == 2)
        return X[x][y-1];
    return X[x][y];
}

int Bfs(int tx, int ty)
{
    int vx, vy, dx, dy, tmp;
    queue<int>q;
    for(int i = 1; i <= y_max; i++)
        for(int j = 1; j <= x_max; j++)
            dis[i][j] = INF;
    dis[1][1] = 0;
    q.push(1);
    q.push(1);
    while(!q.empty())
    {
        vx = q.front();
        q.pop();
        vy = q.front();
        q.pop();
        for(int i = 0; i < 4; i++)
        {
            dx = vx+dt[i][0];
            dy = vy+dt[i][1];
            tmp = Change(vx, vy, i);
            if(Border_Judge(dx, dy) && dis[dx][dy] > dis[vx][vy] + tmp)
            {
                dis[dx][dy] = dis[vx][vy] + tmp;
                q.push(dx);
                q.push(dy);
            }
        }
    }
    return (dis[tx][ty] == INF ? -1 : dis[tx][ty]);
}

void run()
{
    int m, n, x, y, d, t;
    double x_begin, y_begin;
    while(~scanf("%d%d", &m, &n))
    {
        if(m == -1 && n == -1)
            break;
        x_max = y_max = -1;
        memset(X, 0, sizeof(X));
        memset(Y, 0, sizeof(Y));
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d%d", &x, &y, &d, &t);
            if(d)
            {
                for(int j = 0; j < t; j++)
                {
                    Y[x][y+j+1] = Wall;
                }
                x_max = max(x+1, x_max);
                y_max = max(y+t+1, y_max);
            }
            else
            {
                for(int j = 0; j < t; j++)
                {
                    X[x+j+1][y] = Wall;
                }
                x_max = max(x+t+1, x_max);
                y_max = max(y+1, y_max);
            }
        }
        for(int i = 0; i < n; i++)
        {
            scanf("%d%d%d", &x, &y, &d);
            if(d)
                Y[x][y+1] = Door;
            else
                X[x+1][y] = Door;
        }
        scanf("%lf%lf", &x_begin, &y_begin);
        if(!(x_begin >=1 && x_begin <= 199 && y_begin >= 1 && y_begin <= 199))
            printf("0
");
        else
            printf("%d
", Bfs((int)x_begin+1, (int)y_begin+1));
    }
}

int main(void)
{
    run();

    return 0;
}