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,

1 #include <map>
  2 #include <stack>
  3 #include <queue>
  4 #include <math.h>
  5 #include <stdio.h>
  6 #include <string.h>
  7 #include <iostream>
  8 #include <limits.h>
  9 #include <algorithm>
 10 #define LL long long
 11 #define min(a,b) (a>b?b:a)
 12 #define max(a,b) (a>b?a:b)
 13 #define eps 1e-9
 14 #define INF 1 << 30
 15 using namespace std;
 16 
 17 #define Door 1
 18 #define Wall INF
 19 
 20 int x_max, y_max;
 21 int X[210][210], Y[210][210];
 22 int dis[210][210];
 23 int dt[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
 24 
 25 bool Border_Judge(int x, int y)
 26 {
 27     if(x > 0 && x <= x_max && y > 0 && y <= y_max)
 28         return true;
 29     return false;
 30 }
 31 
 32 int Change(int x, int y, int i)
 33 {
 34     if(i == 0)
 35         return Y[x-1][y];
 36     if(i == 1)
 37         return Y[x][y];
 38     if(i == 2)
 39         return X[x][y-1];
 40     return X[x][y];
 41 }
 42 
 43 int Bfs(int tx, int ty)
 44 {
 45     int vx, vy, dx, dy, tmp;
 46     queue<int>q;
 47     for(int i = 1; i <= y_max; i++)
 48         for(int j = 1; j <= x_max; j++)
 49             dis[i][j] = INF;
 50     dis[1][1] = 0;
 51     q.push(1);
 52     q.push(1);
 53     while(!q.empty())
 54     {
 55         vx = q.front();
 56         q.pop();
 57         vy = q.front();
 58         q.pop();
 59         for(int i = 0; i < 4; i++)
 60         {
 61             dx = vx+dt[i][0];
 62             dy = vy+dt[i][1];
 63             tmp = Change(vx, vy, i);
 64             if(Border_Judge(dx, dy) && dis[dx][dy] > dis[vx][vy] + tmp)
 65             {
 66                 dis[dx][dy] = dis[vx][vy] + tmp;
 67                 q.push(dx);
 68                 q.push(dy);
 69             }
 70         }
 71     }
 72     return (dis[tx][ty] == INF ? -1 : dis[tx][ty]);
 73 }
 74 
 75 void run()
 76 {
 77     int m, n, x, y, d, t;
 78     double x_begin, y_begin;
 79     while(~scanf("%d%d", &m, &n))
 80     {
 81         if(m == -1 && n == -1)
 82             break;
 83         x_max = y_max = -1;
 84         memset(X, 0, sizeof(X));
 85         memset(Y, 0, sizeof(Y));
 86         for(int i = 0; i < m; i++)
 87         {
 88             scanf("%d%d%d%d", &x, &y, &d, &t);
 89             if(d)
 90             {
 91                 for(int j = 0; j < t; j++)
 92                 {
 93                     Y[x][y+j+1] = Wall;
 94                 }
 95                 x_max = max(x+1, x_max);
 96                 y_max = max(y+t+1, y_max);
 97             }
 98             else
 99             {
100                 for(int j = 0; j < t; j++)
101                 {
102                     X[x+j+1][y] = Wall;
103                 }
104                 x_max = max(x+t+1, x_max);
105                 y_max = max(y+1, y_max);
106             }
107         }
108         for(int i = 0; i < n; i++)
109         {
110             scanf("%d%d%d", &x, &y, &d);
111             if(d)
112                 Y[x][y+1] = Door;
113             else
114                 X[x+1][y] = Door;
115         }
116         scanf("%lf%lf", &x_begin, &y_begin);
117         if(!(x_begin >=1 && x_begin <= 199 && y_begin >= 1 && y_begin <= 199))
118             printf("0\n");
119         else
120             printf("%d\n", Bfs((int)x_begin+1, (int)y_begin+1));
121     }
122 }
123 
124 int main(void)
125 {
126     run();
127 
128     return 0;
129 }

Finding Nemo