pta 7-5 迷宫-深度策略

程序设计竞赛引导(选修课)老师布置的作业。第一次独立写出来DFS，挺开心的，这个题和常规的DFS还不太一样。写了一晚上，另外还学会了动态分配数组大小。认识到了自己在堆空间分配线性地址这个想法的局限性。

一个陷入迷宫的老鼠如何找到出口的问题。老鼠希望系统性地尝试所有的路径之后走出迷宫。如果它到达一个死胡同，将原路返回到上一个位置，尝试新的路径。在每个位置上老鼠可以向八个方向

运动，顺序是从正东开始按照顺时针进行。无论离出口多远，它总是按照这样的顺序尝试，当到达一个死胡同之后，老鼠将进行“回溯”。迷宫只有一个入口，一个出口，设计程序要求输出迷宫的一条通路。迷宫用二维存储结构表示，1表示障碍，0表示通路；采用回溯法设计求解通路的算法。要求如下：
1、实现栈的相关操作；
2、利用栈实现回溯算法输出路径；

输入格式:

输入包括三部分：
第一个输入是迷宫大小；第二个输入是迷宫的状态；第三个输入是入口和出口位置

输出格式:

反向输出探索的路径，注意包括入口和出口位置。每个位置之间用分号;分隔。

输入样例:

9
1 1 1 1 1 1 1 1 1
1 0 0 1 1 0 1 1 1
1 1 0 0 0 0 0 0 1
1 0 1 0 0 1 1 1 1
1 0 1 1 1 0 0 1 1
1 1 0 0 1 0 0 0 1
1 0 1 1 0 0 0 1 1
1 1 1 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1
1 1 7 7

输出样例:

7 7;6 6;5 7;4 6;4 5;3 4;2 5;2 4;2 3;1 2;1 1;

代码:

错误了好多次，所以注释啥的很多，写得细碎

#include <bits/stdc++.h>
using namespace std;
class solution5 {
public:
	solution5();
	void DFS(int** maze, bool** visited,int,int,int,int);
};
stack<pair<int, int>> s;
bool bSuccess;
//bool Visited[15][15];
void solution5::DFS(int** _Maze, bool** _Visited,int y0,int x0,int y1,int x1) {
	//从东顺序开始
	_Visited[y0][x0] = 1;
	if (y0 == y1 && x0 == x1) { bSuccess = 1; return; }
	if (_Maze[y0][x0 + 1] == 0 && _Visited[y0][x0 + 1] == 0 &&bSuccess==0) {
		s.push(pair<int, int>(y0,x0+1));
		DFS(_Maze, _Visited, y0, x0+1, y1, x1);
	}
	if (_Maze[y0+1][x0 + 1] == 0 && _Visited[y0+1][x0 + 1] == 0 && bSuccess == 0) {
		s.push(pair<int, int>(y0+1, x0 + 1));
		DFS(_Maze, _Visited, y0+1, x0 + 1, y1, x1);
	}
	if (_Maze[y0+1][x0] == 0 && _Visited[y0+1][x0] == 0 && bSuccess == 0)  {
		s.push(pair<int, int>(y0+1, x0 ));
		DFS(_Maze, _Visited, y0+1, x0,y1,x1);
	}
	if (_Maze[y0 + 1][x0-1] == 0 && _Visited[y0 + 1][x0-1] == 0 && bSuccess == 0) {
		s.push(pair<int, int>(y0 + 1, x0-1));
		DFS(_Maze, _Visited, y0 + 1, x0-1, y1, x1);
	}


	if (_Maze[y0][x0 - 1] == 0 && _Visited[y0][x0 - 1] == 0 && bSuccess == 0) {
		s.push(pair<int, int>(y0, x0 - 1));
		DFS(_Maze, _Visited, y0, x0 - 1, y1, x1);
	}
	if (_Maze[y0 - 1][x0 - 1] == 0 && _Visited[y0 - 1][x0 - 1] == 0 && bSuccess == 0) {
		s.push(pair<int, int>(y0 - 1, x0 - 1));
		DFS(_Maze, _Visited, y0 - 1, x0 - 1, y1, x1);
	}
	if (_Maze[y0 - 1][x0] == 0 && _Visited[y0 - 1][x0] == 0 && bSuccess == 0) {
		s.push(pair<int, int>(y0 - 1, x0));
		DFS(_Maze, _Visited, y0 - 1, x0, y1, x1);
	}
	if (_Maze[y0 - 1][x0 + 1] == 0 && _Visited[y0 - 1][x0 + 1] == 0 && bSuccess == 0) {
		s.push(pair<int, int>(y0 - 1, x0 + 1));
		DFS(_Maze, _Visited, y0 - 1, x0 + 1, y1, x1);
	}
	if (bSuccess == 0) {
		//没成功 说明堵住了 出栈
		s.pop();
		return;
	}
	if (bSuccess == 1) {
		//成功了 不出栈
		return;
	}
}
solution5::solution5() {
	int nLoop;
	cin >> nLoop;
	//int[][] maze=(int**)malloc(nLoop*nLoop*4);
	int** maze=new int* [nLoop];//这个只是行
	//还得为每一行分配空间
	for (int i = 0; i < nLoop; i++) {
		maze[i] = new int[nLoop];//二维数组分配完成
	}
	bool** Visited = new bool*[nLoop];
	for (int i = 0; i < nLoop; i++) {
		Visited[i] = new bool[nLoop];//二维数组分配完成
		//memset(Visited[i], 0, sizeof(int)*nLoop);
	}
	for (int i = 0; i < nLoop; i++) {
		for (int j = 0; j < nLoop; j++) {
			Visited[i][j]=0;
		}
	}
	//memset(Visited, 0, nLoop*nLoop * sizeof(int));
	//RtlZeroMemory(Visited, sizeof(int)*nLoop*nLoop);//清空
	//maze[1][1] = 1;
	//printf("分配的地址%p\n", maze);
	//for (int i = 0; i < nLoop; i++) {
	//	for (int j = 0; j < nLoop; j++) {
	//		printf("int[%d][%d]:%p  ", i, j, &maze[i][j]);
	//	}
	//}
	for (int i = 0; i < nLoop; i++) {
		for (int j = 0; j < nLoop; j++) {
			cin >> maze[i][j];
		}
	}
	int x0, y0, x1, y1;
	cin >> x0 >> y0 >> x1 >> y1;
	DFS(maze, Visited, x0, y0, x1, y1);
	int nSize = s.size();
	for (int i = 0; i < nSize; i++) {
		cout << s.top().first << " " << s.top().second<<";";
		
		s.pop();
	}
	cout << x0 << " " << y0 << ";" << endl;
}
int main() {
	solution5 s5;
	return 0;
}