POJ 3984

迷宫问题

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 23870		Accepted: 13902

Description

定义一个二维数组： 

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

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

Sample Input

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

Sample Output

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

真的是太菜了 不知道怎么保存路径 蠢到用单链表链接 然后用栈逆序输出 真的菜哭了，必须要努力学习新姿势，怎么可以这么菜！！！！~

还是纪念一下吧

AC代码

#include <stdio.h>                  //可以看做图来解答，两个节点都为0即可看做一条边，仅限上下左右相邻的节点之间
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <sstream>
#include <stack>
#include <queue>
#include <vector>
#include <algorithm>
#define maxn 100010
using namespace std;
typedef long long ll;
int visit[10][10]={0};
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};//四个方向
typedef struct node
{
  int x;
  int y;                        //节点坐标
  int val;                      //该点的值0或1
  struct node *fr;              //记录上个节点
}node,*nlist;
node f[10][10];
void read()
{
  for(int i=0;i<5;i++)
  {
    for(int j=0;j<5;j++)
     {
        cin>>f[i][j].val;
        f[i][j].x=i;
        f[i][j].y=j;
      }
  }
}
bool judege(int n,int m)           //满足三个条件才可以入队列，没遍历过，该节点值不为1（为1走不通），注意边界
{
  if(f[n][m].val==1)
    return false;
  if(visit[n][m]==1)
    return false;
  if(n<0||n>4||m<0||m>4)
    return false;
  return true;
}
void BFS(int sx,int sy,int ex,int ey)  //起点、终点
{
  queue<nlist> q;
  visit[sx][sy]=1;
  nlist b=&f[sx][sy];
  b->fr=NULL;
  q.push(b);
  while(!q.empty())
  {
    nlist cur;
    cur=q.front();
    q.pop();
    for(int i=0;i<4;i++)               //遍历周围节点
    {
      int x=dir[i][0]+cur->x;
      int y=dir[i][1]+cur->y;
      if(judege(x,y)==true)
      {                               //判断是否可以入队
        nlist n=&f[x][y];
        n->fr=cur;                     //记录路径QAQ...
        q.push(n);
        visit[x][y]=1;
        if(x==ex&&y==ey)              //搜到终点直接结束
          return;
      }
    }
  }
}
void print(int sx,int sy,int ex,int ey)
{
  stack<nlist> s;
  nlist p=&f[ex][ey];
  s.push(p);
  while(p->fr!=NULL)
  {
    p=p->fr;
    s.push(p);
  }
  while(!s.empty())
  {
    nlist n=s.top();
    cout<<"("<<n->x<<", "<<n->y<<")"<<endl;
    s.pop();
  }
}
int main(int argc, char const *argv[])
{
  read();
  BFS(0,0,4,4);
  print(0,0,4,4);
  return 0;
}

加油加油~~