用栈实现迷宫算法

用栈实现迷宫算法

#include <iostream>

using namespace std;

//定义一个迷宫，0为可通的路，
//1表示不可前进的路，并且给迷宫加上了边框，所以在周围会有一圈1
const int M = 8, N = 8;
const int maxSize = 1e4 + 10;

int mg[M + 2][N + 2] = {
	{1,1,1,1,1,1,1,1,1,1},
	{1,0,0,1,0,0,0,1,0,1},
	{1,0,0,1,0,0,0,1,0,1},
	{1,0,0,0,0,1,1,0,0,1},
	{1,0,1,1,1,0,0,0,0,1},
	{1,0,0,0,1,0,0,0,0,1},
	{1,0,1,0,0,0,1,0,0,1},
	{1,0,1,1,1,0,1,1,0,1},
	{1,1,0,0,0,0,0,0,0,1},
	{1,1,1,1,1,1,1,1,1,1}
};

//定义一个结构体，该结构体表示迷宫每个元素的坐标以及方位数。
struct Box {
	int i;
	int j;
	int di;
};

//定义一个迷宫栈，下面包括迷宫栈的一系列的函数
struct SNode {
	Box Data[maxSize];
	int top;
};
typedef SNode* Stack;

void Init(Stack& S)
{
	S = new SNode;
	S->top = -1;
}

bool Push(Stack& S, Box e)
{
	if (S->top == maxSize - 1)
		return false;
	S->top++;
	S->Data[S->top] = e;
	return true;
}

bool Pop(Stack& S, Box& e)
{
	if (S->top == -1)
		return false;
	e = S->Data[S->top];
	S->top--;
	return true;
}

bool GetTop(Stack S, Box& e)
{
	if (S->top == -1)
		return false;
	e = S->Data[S->top];
	return true;
}

bool Empty(Stack S)
{
	return (S->top == -1);

}

void destroy(Stack& S)
{
	free(S);
}

//该算法即为迷宫的算法
bool solve(int xi, int yi, int xe, int ye)
{
	Box e,path[maxSize];
	int i, j, di, i1, j1,k;
	Stack S;
	Init(S);
	bool find;

	e.i = xi; e.j = yi; e.di = -1;
	Push(S, e);
	mg[xi][yi] = -1;
	while (!Empty(S))
	{
		GetTop(S, e);
		i = e.i; j = e.j; di = e.di;
		if (i == xe && j == ye)
		{
			cout << "恭喜你找到了一条迷宫的路径！" << endl;
			k = 0;
			while (!Empty(S))
			{
				Pop(S, e);
				path[k++] = e;
			}
			while (k >= 1)
			{
				k--;
				cout << '(' << path[k].i << ',' << path[k].j << ')' << "	";
				if ((k + 2) % 5 == 0)
				{
					cout << endl;
				}
			}
			destroy(S);
			return true;
		}
		
		find = false;
		while (di < 4 && !find)
		{
			di++;
			switch (di)
			{
			case 0:
				i1 = i - 1; j1 = j; break;
			case 1:
				i1 = i; j1 = j + 1; break;
			case 2:
				i1 = i + 1; j1 = j; break;
			case 3:
				i1 = i; j1 = j - 1; break;
			}
			if (mg[i1][j1] == 0)
				find = true;
		}
		if (find)
		{
			S->Data[S->top].di = di;
			mg[i][j] = -1;
			e.i = i1; e.j = j1; e.di = -1;
			Push(S, e);
		}
		else
		{
			Pop(S, e);
			mg[i][j] = 0;
		}
	}
	destroy(S);
	return false;
}

int main()
{
	solve(1, 1, 8, 8);
}