迷宫求解——附栈的实现

今天我们来完成一个简单的迷宫，首先我们需要一个迷宫地图在文件中，方便我们在文件中读取它。这是地图：

然后我们就进行读取地图，并保存地图到数组里面，这样很方便给出坐标。

接下来我们就要考虑怎么走了，其实很简单，我们只需让当前位置经行查找，上下左右只要是通路就移动到下一个位置，直到找到出口。

那如果走到死胡同了该如何，其实也很容易，这里我们就需要运用回溯法来解决问题。

那么什么事回溯法呢？

回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

当我们走到死路后就退回到上一个位置，继续判断，直到有一个方向是通路就继续走。

完成回溯法就需要用到我们的栈来实现，栈的特点就是在尾部插，尾部删，我们每次走一步就push进去一个数据，当需要退回时就pop一个出来。

这里需要用到栈，我们就自己来实现一把。

<strong>template<typename T>  
class Stack  
{  
public:  
	Stack()  
		:_capacity(0)  
		, _size(0)  
		, _arr(NULL)  
	{}  
	~Stack()  
	{  
		delete[] _arr;  
		_size = 0;  
		_capacity = 0;  
		_arr = NULL;  
	}  
	void Push(const T& data);  
	void Pop();  
	T Top();  
	int Size();  
	bool Empty();  
private:  
	void CheckCapacity()  
	{  
		if (_size >= _capacity)  
		{  
			int NewCapacity = _capacity * 2 + 1;  
			T* tmp = new T[NewCapacity];  
			for (int i = 0; i < _size; i++)  
			{  
				tmp[i] = _arr[i];  
			}  
			delete[] _arr;  
			_arr = tmp;  
			_capacity = NewCapacity;  
		}  
	}  
private:  
	T* _arr;  
	int _capacity;  
	int _size;  
};  

template<typename T>  
bool Stack<T>::Empty()   //判断栈是否为空
{  
	if (_size == 0)  
		return true;  
	else  
		return false;  
}  

template<typename T>  
void Stack<T>::Push(const T& data)  //进栈
{  
	CheckCapacity();  
	_arr[_size++] = data;  
}  

template<typename T>  
void Stack<T>::Pop()  //出栈
{  
	assert(_size>0);  
	--_size;  
}  

template<typename T>  
T Stack<T>::Top()  //返回栈顶元素
{  
	return _arr[_size - 1];  
}  

template<typename T>  
int Stack<T>::Size()  //栈的大小
{  
	return _size;  
}  
</strong>

当我们每走一步就把走过的路置为2，方便判断。

下面就是代码实现：

#include<iostream>  
#include<cassert>  
using namespace std;  

template<typename T>  
class Stack  
{  
public:  
	Stack()  
		:_capacity(0)  
		, _size(0)  
		, _arr(NULL)  
	{}  
	~Stack()  
	{  
		delete[] _arr;  
		_size = 0;  
		_capacity = 0;  
		_arr = NULL;  
	}  
	void Push(const T& data);  
	void Pop();  
	T Top();  
	int Size();  
	bool Empty();  
private:  
	void CheckCapacity()  
	{  
		if (_size >= _capacity)  
		{  
			int NewCapacity = _capacity * 2 + 1;  
			T* tmp = new T[NewCapacity];  
			for (int i = 0; i < _size; i++)  
			{  
				tmp[i] = _arr[i];  
			}  
			delete[] _arr;  
			_arr = tmp;  
			_capacity = NewCapacity;  
		}  
	}  
private:  
	T* _arr;  
	int _capacity;  
	int _size;  
};  

template<typename T>  
bool Stack<T>::Empty()   //判断栈是否为空
{  
	if (_size == 0)  
		return true;  
	else  
		return false;  
}  

template<typename T>  
void Stack<T>::Push(const T& data)  //进栈
{  
	CheckCapacity();  
	_arr[_size++] = data;  
}  

template<typename T>  
void Stack<T>::Pop()  //出栈
{  
	assert(_size>0);  
	--_size;  
}  

template<typename T>  
T Stack<T>::Top()  //返回栈顶元素
{  
	return _arr[_size - 1];  
}  

template<typename T>  
int Stack<T>::Size()  //栈的大小
{  
	return _size;  
}  


#define N 10
struct POS 
{
	POS(const int& row=0,const	int col=0)
		:_row(row)
		,_col(col)
	{}
	size_t _row;
	size_t _col;
};

void Getmaze(int *arr)   //从文件中读取地图，保存在数组里
{
	FILE* maze= fopen("MazeMap.txt","r");
	assert(maze!=NULL);
	int i=0,j=0;
	for (i=0;i<N;i++)
	{
		for (j=0;j<N;)
		{
			char c=fgetc(maze);
			if (c=='0'||c=='1')
			{
				arr[i*N+j]=c-'0';
				j++;
			}
			continue;
		}
	}
	fclose(maze);
}

void Printmaze(int *arr)   //打印地图
{
	for (int i=0;i<N;i++)
	{
		for (int j=0;j<N;j++)
		{
			cout<<arr[i*N+j]<<" ";
		}
		cout<<endl;
	}
}

bool Checkpath(int *maze, POS &next)   //检查下个路是否是通路
{
	if (next._col < N && next._row < N
		&& next._col >= 0 && next._row >= 0
		&& (maze[next._row*N + next._col] == 0))
		return true;
	else
		return false;
}
bool Getpath(int *maze, int row, int col, Stack<POS> &path, POS enter)
{
	POS cur = enter;
	POS next;
	path.Push(cur);
	while (!path.Empty())
	{
		if (cur._row != enter._row&&cur._col != enter._col && (cur._row == row - 1 || cur._row == 0 || cur._col == col - 1))
		{
			maze[cur._row*N + cur._col] = 2;           //走过的路置为2
			return true;

		}

		maze[cur._row*N + cur._col] = 2;

		//右
		next = cur;
		++next._col;
		if (Checkpath(maze, next))
		{
			cur = next;
			path.Push(cur);
			continue;
		}


		//左
		next = cur;
		--next._col;
		if (Checkpath(maze, next))
		{
			cur = next;
			path.Push(cur);
			continue;
		}

		//上
		next = cur;
		--next._row;
		if (Checkpath(maze, next))
		{
			cur = next;
			path.Push(cur);
			continue;
		}

		//下
		next = cur;
		++next._row;
		if (Checkpath(maze, next))
		{
			cur = next;
			path.Push(cur);
			continue;
		}
		cur = path.Top();
		path.Pop();
	}
	return false;
}
void test()
{
	Stack<POS> path;
	int maze[N][N];
	Getmaze((int *)maze);
	Printmaze((int *)maze);
	cout << endl;
	Getpath((int *)maze, N, N, path, POS(2, 0));
	cout << "找到出口后：" << endl;
	Printmaze((int *)maze);

}

int main()
{
	test();
	system("pause");
	return 0;
}

到此迷宫的问题就完了。

这是运行后的结果：