迷宫问题的简单栈实现

问题描述：

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

对于本问题需用栈实现“穷举求解”算法，即：从入口出发，顺着某一个方向进行探索，若能走通，则继续往前进；否则沿着原路退回，换一个方向继续探索，直至出口位置，求得一条通路。加入所有可能的通路都探索到而未能到达出口，则所设定的迷宫没有通路。迷宫数据是一个n阶矩阵用二维数组存储，起点为（1,1），终点为（n,n），再在迷宫外围加上一层围墙（默认为1，不需用户输入，用户只需输入迷宫数据即可），对于迷宫中每个数据都有四个方向可通。

#include<malloc.h>
#include<bits/stdc++.h>
#define N 10
using namespace std;
typedef struct Dot
{
    int x,y;
}Dot;
typedef Dot DATA_TYPE;
typedef struct Maze
{
    Dot init,the_end;
    int map[N][N];
}Maze;
typedef struct
{
	DATA_TYPE *data;
	int top;//此处的top意为当前手打栈的容量，capacity意为最大承载量
	int capacity;
}Stack;
int n;bool vis[N][N],flag;
int dx[4]={-1,1,0,0},dy[4]={0,0,1,-1};
int InitStack(Stack* s,int size)
{
	s->data = (DATA_TYPE*)malloc(size*sizeof(DATA_TYPE));

	if(s->data == NULL) //如果空间动态非配出错，就报错
		return 0;

	s->capacity = size;
	s->top = 0;
	return 1;
}

int IsFull(Stack* s)
{
	if(s->top >= s->capacity)return 1;
	else return 0;
}

int IsEmpty(Stack *s)
{
	if(s->top <= 0)return 1;
	else return 0;
}


int Push(Stack *s ,DATA_TYPE d)
{
	if(IsFull(s))return 0;
	else
	{
		s->data[s->top++]=d;
		return 1;
	}
}

int Pop(Stack* s,DATA_TYPE *d)
{
	if(IsEmpty(s))
		return 0;
	else
	{
		s->top--;
		*d=s->data[s->top];
		return 1;
	}
}

int GetTop(Stack*s,DATA_TYPE *d)
{
	if(IsEmpty(s))return 0;
	else
	{
		*d = s->data[s->top-1];
		return 1;
	}
}

int ClearStack(Stack* s)
{
	s->top=0;
	return 1;
}

int DestoryStack(Stack* s)
{
	free(s->data) ;
	s->top=-1;
	s->capacity=-1;
	return 1;
}
Maze Maze_init(Maze *M)//迷宫初始化
{
	scanf("%d",&n);
	for (int i = 1;i <=n;i++)
	{
		for (int j = 1;j <=n;j++)
		{
			scanf("%d",&M->map[i][j]);
		}
	}
	M->init={1,1},M->the_end={n,n};
	return *M;
}
inline bool ok(Dot current,Maze *M)
{
    if(current.x<1||current.y<1||current.x>n||current.y>n||vis[current.x][current.y]||M->map[current.x][current.y]==0)
    {
       // cout<<(current.x<1||current.y<1||current.x>n||current.y>n)<<endl;
        /*cout<<vis[current.x][current.y]<<endl;
        cout<<M->map[current.x][current.y]<<endl;*/
        return false;
    }
    return true;
}
inline void print_stack(Stack *p)
{
    flag=1;
    while(!IsEmpty(p))
    {
        Dot temp;
        Pop(p,&temp);
        cout<<temp.x<<" "<<temp.y<<endl;
    }
}
inline void find_path(Maze *M,Dot current,Stack *p)
{
    //cout<<current.x<<" "<<current.y<<endl;
    if(current.x==n&&current.y==n)
    {
        print_stack(p);
        return;
    }
    //cout<<ok(current,M)<<endl;
    if(!ok(current,M))return ;
    int tempx=current.x,tempy=current.y;
    vis[tempx][tempy]=1;
    Push(p,current);
    for(int i=0;i<4;i++)
    {
        Dot k=current;
        k.x+=dx[i],k.y+=dy[i];
        find_path(M,k,p);
    }
    Pop(p,&current);
    return ;
}
inline void work()
{
    Maze M;
    Stack p;
    InitStack(&p,(N+5)*(N+5) );
    M=Maze_init(&M);
    Dot current=M.init;
    //cout<<current.x<<" "<<current.y<<endl;
    find_path(&M,current,&p);
    if(!flag)cout<<-1<<endl;
}

int main()
{
   work();
   return 0;
}