栈的应用之迷宫

利用栈对迷宫求解，采用的基本方法是回溯法，其实也算是一种暴力破解吧...毕竟是将一个一个方块检验直至终点或者栈空。

入栈：当栈顶元素方块周围有可行方块时，将该可行方块入栈

出栈：当栈定元素的方块周围都没有可行方块时，出栈

有几点需要注意：

1.当栈顶元素弹出时，我们又要重新对栈顶元素周围的方块进行检验，为避免进入死循环，所以需要记录一下该栈顶元素已经记录到周围哪一块

2.当入栈的时候，原栈顶元素与新栈顶元素之间都成周围元素关系，为避免死循环，需要将每一个进入栈中的元素在迷宫中变成“不通”，即变成不可行方块

还有一点需要说明：
一个迷宫可能有多个不同路径，利用栈的不能够找到最优路径...所以路径可能不一致...

我为了熟悉C++中的stack唯一没有自己对stack重新定义，所以可能复杂了...莫怪！

#ifndef MAZE_H
#define MAZE_H


#include<stack>
using namespace std;

const int COL = 10;
const int ROW = 10;

struct Node{
	int flag;
	int i;
	int j; 
	int count;
public:
	Node(){
		flag = 0;
		i = 0;
		j = 0;
		count = 0;
	}

	Node & operator=(const Node &node){
		
		this->i = node.i;
		this->j = node.j;
		this->count = node.count;
	}
	bool operator==(const Node &node){
		return(i == node.i && j== node.j);
	}
	bool operator!=(const Node &node){
		return (i != node.i || j != node.j);
	}
};
class Maze{

private:
	Node start , end;
	bool haspath;
	stack<Node> path;
	Node maze[ROW][COL];


public:
	Maze(){ haspath = false; }
	~Maze(){};
	void createMaze(const int num[][COL] , int row ,int col);
	void getPath(int si ,int sj ,int ei ,int ej);//输入开始和终点位置（s==start ,e==end）
	void display() ;
	
};


#endif 

#include"maze.h"
#include<iostream>

void Maze::createMaze(const int num[][COL], int row, int col){
	
	for (int i = 0; i < row; i++)
		for (int j = 0; j < col; j++){
			maze[i][j].flag = num[i][j];
			maze[i][j].j = j; 
			maze[i][j].i = i;
		}
}

void Maze::getPath(int si, int sj, int ei, int ej){
	
	Node start = maze[si][sj], end = maze[ei][ej];
	
	path.push(maze[si][sj]);
	
	maze[si][sj].flag = 1;//说明中的第二点
	
	
	
	while (!path.empty()){
		
		Node temp = path.top();

		if (temp == end) { haspath=true; break; }
		
		int i = temp.count, tempi , tempj;

		bool flag= false;

		while (i < 4){
			
			switch (i){ 
				case 0: tempi = temp.i + 1; tempj = temp.j; break;
				case 1: tempi = temp.i; tempj = temp.j + 1; break;
				case 2: tempi = temp.i - 1; tempj = temp.j; break;
				case 3: tempi = temp.i; tempj = temp.j - 1; break;
			}

			if (maze[tempi][tempj].flag == 0){

				
				temp.count = i + 1;//说明中的第一点
				path.pop();
				path.push(temp);
				path.push(maze[tempi][tempj]);
				
				maze[tempi][tempj].flag = 1;//说明中的第二点

				
				flag =true;
				
				break;
			}

			else i++;
			
		}
		
		if (!flag) {
			path.pop();
			maze[temp.i][temp.j].flag = 0;//弹出之后可以恢复为可行
		}

	}

}

void Maze::display() {

	if (path.empty()) cout << "没有路径！" << endl;
	
	int i = 1;
	while (!path.empty()){
		
		Node node = path.top();
		
		cout <<" ( "<< node.i << " , " << node.j<<" ) ";
		
		if (i%5==0)	cout<< endl;
		path.pop();
		i++;
	}
}

#include<iostream>
#include"maze.h"
using namespace std;
int main(){
	//迷宫初始化
	int num[ROW][COL] = 
						{ { 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 }};

	Maze maze;
	maze.createMaze(num, ROW, COL);
	maze.getPath(1, 1, 8, 8);
	maze.display();
	system("pause");

	return 0;
}