1089 简单迷宫问题(二维广度优先搜索）

1089 1089 简单迷宫问题(二维广度优先搜索）

• 描述： PIPI定义了一个二维数组：
  int maze[5][5] = {
  0, 1, 0, 0, 0,
  0, 1, 0, 1, 0,
  0, 0, 0, 0, 0,
  0, 1, 1, 1, 0,
  0, 0, 0, 1, 0,
  };
  它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，请找出从左上角到右下角的最短路线。

• 输入：仅一组测试用例。一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

• 输出：左上角到右下角的最短路径，格式如样例所示。

• 输入示例

  0 1 0 0 0
  0 1 0 1 0
  0 0 0 0 0
  0 1 1 1 0
  0 0 0 1 0
  

• 输出示例

  (0, 0)
  (1, 0)
  (2, 0)
  (2, 1)
  (2, 2)
  (2, 3)
  (2, 4)
  (3, 4)
  (4, 4)
  

• 代码块

  #include <bits/stdc++.h>
  using namespace std;
  
  #define inf 9999
  const int N = 5;
  int numvex;
  int dx[] = {0, 0, 1, -1};
  int dy[] = {1, -1, 0, 0};//方向数组
  struct Node{
      int x, y;//此顶点的坐标
      int state;//表示此顶点的状态(是否为墙)
      int px, py;//显示实际路径(邻接到此点的坐标)
      int Dist;//表示从起点到到此顶点的距离
      int Known;//表示此顶点是否被访问
  };
  
  typedef struct Node Table[N][N];//这里用表来存储地图，当然也附带存了一些其他东西
  
  void InitTable(Table &T){
  	//初始化表
      numvex = 5;
      for(int i=0; i<numvex; ++i){
          for(int j=0; j<numvex; ++j){
              T[i][j].x = i; T[i][j].y = j;
              scanf("%d", &T[i][j].state);
              T[i][j].px = -1; T[i][j].py = -1;
              T[i][j].Dist = inf;
              T[i][j].Known = 0;
          }
      }
  }
  
  void dfs(Table T, Node n){//使用深度遍历来重现路径
      if(n.px==-1 && n.py==-1){
          printf("\(%d, %d\)\n", n.x, n.y);
          return;
      }
      dfs(T, T[n.px][n.py]);
      printf("\(%d, %d\)\n", n.x, n.y);
  }
  
  void bfs(Table &T){
      queue<Node> q;
      Node n;
      q.push(T[0][0]);//显然从地图左上角开始于(0, 0)点
      T[0][0].Known = 1; T[0][0].Dist = 0;//这里只能在入队的时候就将known设为1（不然会有重复）
      while(!q.empty()){
          n = q.front();
          q.pop();
          if(n.x == 4 && n.y == 4){//到达终点    
              dfs(T, n);
              return;
          }
          for(int i=0; i<4; i++){//相当于寻找下一个邻接点(这里是二维点)
              int nx = n.x + dx[i];
              int ny = n.y + dy[i];
              if(nx>=0 && nx<5 && ny>=0 && ny<5 && T[nx][ny].Known==0 && T[nx][ny].state==0){
                  T[nx][ny].Known = 1;
                  T[nx][ny].Dist = T[n.x][n.y].Dist + 1;
                  T[nx][ny].px = n.x; T[nx][ny].py = n.y;
                  q.push(T[nx][ny]);//一定要在修改过信息之后才能如队列，队列中保存的是其入队列时的状态，是原数据的拷贝
              }
          }
      }
  }
  
  
  int main(){
      Table T;
      InitTable(T);
      bfs(T);
      system("pause");
      return 0;
  }