迷宫问题 192132-01

迷宫问题

以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。

要求：

（1）首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组(i,j,d)的形式输出，其中(i,j)指示迷宫中的一个坐标，d表示走到下一坐标的方向。

（2）测试几组数据，数据的规模由小变大，即网格越来越小，障碍越来越复杂。

（3）实现该问题的可视化界面。

#include<stdio.h>     
#include<iostream>     
#include<math.h>     
#include<stdlib.h>     
#include<ctype.h>     
#include<algorithm>     
#include<vector>     
#include<string.h>     
#include<stack>     
#include<set>     
#include<map>     
#include<sstream>     
#include<time.h>     
#include<utility>     
#include<malloc.h>     
#include<stdexcept>     
#include<iomanip>     
#include<iterator>     

using namespace std;  

int n, m, sx, sy, ex, ey, t;  
int p[110][110];  
char MAP[110][110];
int vis[110][110];  
int dir[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };  

struct node  
{  
  int x;  
  int y;  
};  

struct node pre[30][30];//存储节点前一个位置   


//  栈   
#define DataType node                  

struct Node;                         
typedef struct Node *PNode;           

typedef struct Node                   
{  
  DataType info;                  
  PNode link;                     
}Node;  

typedef struct LinkStack             
{  
  PNode top;          
}LinkStack;  

typedef struct LinkStack * PLinkStack;     
PLinkStack createEmptyStack(void);  
int isEmptyStack(PLinkStack stack);  
int push(PLinkStack stack, DataType x);  
int pop(PLinkStack stack);  
DataType getTop(PLinkStack stack);  
void showStack(PLinkStack stack);  
void setEmpty(PLinkStack stack);  
void destroyStack(PLinkStack stack);  

PLinkStack createEmptyStack(void)  
{  
  PLinkStack stack = (PLinkStack)malloc(sizeof(struct LinkStack));  
  if (stack == NULL)  
    printf("存储分配失败，请重建栈！\n");  
  else  
    stack->top = NULL;  
  return stack;  
}  

int isEmptyStack(PLinkStack stack)  
{  
  return (stack->top == NULL);  
}  

int push(PLinkStack stack, DataType x)  
{  
  PNode p = (PNode)malloc(sizeof(struct Node));  
  if (p == NULL)  
  {  
    printf("新结点分配内存失败，进栈失败，请重试！\n");  
    return 0;  
  }  
  else  
  {  
    p->info = x;  
    p->link = stack->top;       
    stack->top = p;  
    return 1;  
  }  
}  

int pop(PLinkStack stack)  
{  
  if (isEmptyStack(stack))  
  {  
    printf("栈为空！\n");  
    return 0;  
  }  
  else  
  {  
    PNode p;  
    p = stack->top;   //删除最后一个结点     
    stack->top = stack->top->link;  
    free(p);  
    return 1;  
  }  
}  

DataType getTop(PLinkStack stack)  
{  
  if (isEmptyStack(stack))  
  {  
    printf("栈为空！取栈顶元素失败！\n");  
  }  
  return (stack->top->info);  
}  

void showStack(PLinkStack stack)  
{  
  if (isEmptyStack(stack))  
    printf("当前栈为空！无内容可显示。\n");  
  else  
  {  
    PNode p;  
    p = stack->top;  
    printf("顶--> ");  
    while (p->link != NULL)  
    {  
      printf("%d ", p->info);  
      p = p->link;  
    }  
    printf("%d ", p->info);     
    printf("-->底\n");  
  }  
}  

void setEmpty(PLinkStack stack)  
{  
  stack->top = NULL;  
}  

void destroyStack(PLinkStack stack)  
{  
  if (stack)  
  {  
    stack->top = NULL;  
    free(stack);  
  }  
}  
///   

int check(int x, int y)  
{  
  if (x >= 0 && x < m && y >= 0 && y < n)  
    return 1;  
  return 0;  
}  

void printf_path()  
{  
  node ss,sss;  

  DataType data;  
  PLinkStack stack;  

  stack = createEmptyStack();  

  ss.x = ex;  
  ss.y = ey;  

  while (1)  
  {  
    push(stack, ss);  
    if (ss.x == sx && ss.y == sy)  
      break;  
    ss = pre[ss.x][ss.y];  
  }  

  int pres, presy;  
  printf ("           行走路径 文字描述如下：\n\n\n");
  while (!(isEmptyStack(stack)))  
  {  
    ss = getTop(stack);  
    pop(stack);  
    MAP[ss.x+1][ss.y+1] = '*';
    if (!(isEmptyStack(stack)))  
      sss = getTop(stack);  
    printf("           ");printf("此刻坐标(%d, %d)  ", ss.x, ss.y);  

    if (!(isEmptyStack(stack)))  
    {  
      if (sss.x == ss.x && sss.y == ss.y + 1)  
          printf("向右走\n"); 
      if (sss.x == ss.x && sss.y == sss.y - 1)  
          printf("向左走\n");  
          
      if (sss.x == ss.x + 1 && sss.y == sss.y)  
          printf("向下走\n");
      if (sss.x == ss.x - 1 && sss.y == sss.y)  
          printf("向上走\n"); 
    }  
  }printf("到达终点!\n\n\n\n");  
  printf ("           行走路径图如下：\n");
  
  for(int i=0;i<=m+1;i++)
  {
    printf("           ");
    for(int j=0;j<=n+1;j++)
    {
      if (j==0 || j== n+1)
        printf("| ");
      else if (i == 0 || i == m+1)
        printf("—");
      else 
        printf("%c ",MAP[i][j]);
    }
    printf("\n");
  }
}  

队列   

#define Error( str )        FatalError( str )   
#define FatalError( str )   fprintf( stderr, "%s\n", str ), exit( 1 )   
#define  ElementType node   

#define MAXQUEUE 100   

typedef struct NODE  
{  
  ElementType data;  
  struct NODE* nextNode;  
} NODE;  
typedef struct queue  
{  
  NODE* front;    // 对首指针   
  NODE* rear;     // 队尾指针   
  int items;      // 队列中项目个数   

} *ptrQueue;  
typedef ptrQueue Queue;  
int IsEmpty(Queue q);  
int IsFull(Queue q);  
Queue CreateQueue(void);  
void DisposeQueue(Queue q);  
void MakeEmpty(Queue q);  
void Enqueue(ElementType x, Queue q);  
ElementType Front(Queue q);  
void Dequeue(Queue q);  

int IsFull(Queue q)  
{  
  return q->items == MAXQUEUE;  
}  

int IsEmpty(Queue q)  
{  
  return q->items == 0;  
}  
Queue CreateQueue(void)  
{  
  Queue q;  

  q = (Queue)malloc(sizeof(struct NODE));  
  if (NULL == q)  
    Error("空间不足，队列内存分配失败！");  

  q->front = (NODE*)malloc(sizeof(NODE));  
  if (NULL == q->front)  
    Error("空间不足，队列首节点内存分配失败！");  

  q->rear = (NODE*)malloc(sizeof(NODE));  
  if (NULL == q->rear)  
    Error("空间不足，队列尾节点内存分配失败！");  

  q->items = 0;  

  return q;  
}  

void DisposeQueue(Queue q)  
{  
  MakeEmpty(q);  
  free(q);  
}  

void MakeEmpty(Queue q)  
{  
  if (q == NULL)  
    Error("必须先使用CreateQueue创建队列！");  

  while (IsEmpty(q))  
    Dequeue(q);  
}  

void Enqueue(ElementType x, Queue q)  
{  
  if (IsFull(q))  
    Error("队列已满！");  

  NODE* pnode;  
  pnode = (NODE*)malloc(sizeof(NODE));  
  if (NULL == pnode)  
    Error("新节点分配内存失败！");  

  pnode->data = x;  
  pnode->nextNode = NULL;  
  if (IsEmpty(q))  
    q->front = pnode;           // 项目位于首端   
  else  
    q->rear->nextNode = pnode;  // 链接到队列尾端   
  q->rear = pnode;                    // 记录队列尾端的位置   
  q->items++;                     // 项目数加1   

  return;  
}  

void Dequeue(Queue q)  
{  
  if (IsEmpty(q))  
    Error("队列本身为空！");  

  NODE* pnode;  
  pnode = q->front;  
  q->front = q->front->nextNode;  
  free(pnode);  

  q->items--;  
  if (q->items == 0)  
    q->rear = NULL;  

  return;  
}  

ElementType Front(Queue q)  
{  
  if (!IsEmpty(q))  
    return q->front->data;  
  Error("队列为空\n");  
}  

ElementType FrontAndDequeue(Queue q)  
{  
  ElementType x;  

  if (IsEmpty(q))  
    Error("队列为空！");  
  else  
  {  
    q->items--;  
    x = q->front->data;  
    q->front = q->front->nextNode;  
  }  

  return x;  
}  

///   

int bfs()  
{  
  memset(vis, 0, sizeof(vis));  

  Queue sqQueue;  
  sqQueue = CreateQueue();  

  node qq, qqq;  

  qq.x = sx;  
  qq.y = sy;  
  vis[sx][sy] = 1;  

  Enqueue(qq, sqQueue);  

  while (!IsEmpty(sqQueue))  
  {  
    qq = Front(sqQueue);  
    Dequeue(sqQueue);  

    if (qq.x == ex && qq.y == ey)  
    {  
      printf_path();  
      return 1;  
    }  

    for (int i = 0; i < 4; i++)  
    {  
      int x = qq.x + dir[i][0];  
      int y = qq.y + dir[i][1];  

      if (!check(x, y) || vis[x][y] || p[x][y] == 1)  
        continue;  

      qqq = qq;  
      qqq.x = x;  
      qqq.y = y;  

      pre[qqq.x][qqq.y] = qq;  

      vis[x][y] = 1;  
      Enqueue(qqq, sqQueue);  
    }  
  }  
  return 0;  
}  


int main()  
{  
  printf("请输入迷宫长和宽\n");  
  while (cin >> m >> n)  
  {  
    printf("输入起点坐标和终点坐标\n");  
    scanf("%d%d%d%d",&sx,&sy,&ex,&ey);  
    printf("请输入迷宫\n");  
    for (int i = 0; i < m; i++)  
    {  
      for (int j = 0; j < n; j++)  
      {  
        cin >> p[i][j];  
        MAP[i+1][j+1] = p[i][j] + '0';
      }  
    }  
    int ans = bfs();  
    if (ans == 0)  
      printf("不存在起点到终点的通路\n\n\n\n");  
    printf("\n\n\n\n");  
    printf("是否继续 1.yes 2.no\n ");  
    scanf("%d",&t);  
    if (t == 2) { printf("          再见   ,谢谢使用本系统！\n\n\n"); return 0; }  
    printf("\n\n\n\n");  
    printf("请输入迷宫长和宽\n");  
  }  
  return 0;  
}

测试数据：

5 5
0 0 4 4
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 1
0 0 0 1 0

1
5 5
0 0 4 4
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

2