使用C++解决迷宫深度搜索路径问题解法(一)

// 深度遍历迷宫路径搜索.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

/*
深度遍历搜索迷宫路径，软件运行要求如下：

请输入迷宫的行列数(例如：10 10):5 5
请输入迷宫的路径信息(0表示可以走，1表示不能走):0 0 0 1 1 1 0 0 0 1 1 1 0 1 1 1 1 0 0 1 1 1 1 0 0
0 0 0 1 1
1 0 0 0 1
1 1 0 1 1
1 1 0 0 1
1 1 1 0 0
迷宫路径搜索中...
>>>如果没有路径，直接输出<<<
不存在一条迷宫路径！
>>>如果有路径，直接输出<<<
* * * 1 1
1 0 * 0 1
1 1 * 1 1
1 1 * * 1
1 1 1 * *
*/

// 定义迷宫节点路径信息
class Node
{
public:
	int _x;
	int _y;
	int _val; // 节点的值
	int _state[4]; // 记录节点四个方向的状态
	bool _yes;//记录当前节点是否为路径
};

// 栈
class SeqStack
{
public:
	SeqStack(int size = 10)
		:_top(0)
		, _size(size)
	{
		_pstack = new Node[size];
	}
	~SeqStack()
	{
		delete[]_pstack;
		_pstack = nullptr;
	}
	SeqStack(const SeqStack&) = delete;
	void operator=(const SeqStack&) = delete;
	
	void push(Node &node) 
	{
		if (full())
		{
			expand();
		}
		_pstack[_top] = node;
		_top++;
	} // 入栈操作
	void pop() 
	{
		if (empty())
			return;
		_top--;
	} // 出栈操作
	Node top()const 
	{
		return _pstack[_top - 1];
	} // 查看栈顶元素
	bool full()const
	{
		return _top == _size;
	} // 判断栈满
	bool empty()const 
	{
		return _top == 0;
	} // 判断栈空
private:
	Node *_pstack;
	int _top; // 记录栈顶位置
	int _size; // 记录空间大小

	void expand() 
	{
		this->_size *= 2;
		Node *tmp = new Node[_size];
		for (int i = 0; i <= _top - 1; i++)
		{
			tmp[i] = this->_pstack[i];
		}
		delete[] _pstack;
		_pstack = tmp;
	} // 栈的扩容函数，2倍空间大小扩容
}; 

// 迷宫
class Maze
{
public:
	Maze(int row, int col)
		:_row(row)
		, _col(col)
	{
		_pMaze = new Node*[_row];
		for (int i = 0; i < _row; ++i)
		{
			_pMaze[i] = new Node[_col];
		}
	}

	void initNode(int x, int y, int val)
	{
		_pMaze[x][y]._x = x;
		_pMaze[x][y]._y = y;
		_pMaze[x][y]._val = val;
		_pMaze[x][y]._yes = false;
	}
	void setNodeState()
	{
		/*	0 0 0 1 1
			1 0 0 0 1
			1 1 0 1 1
			1 1 0 0 1
			1 1 1 0 0*/
		for (int i = 0; i < _row; ++i)
		{
			for (int j = 0; j < _col; ++j)
			{
				for (int k = 0; k < 4; k++)
					_pMaze[i][j]._state[k] = 1;
				if (j + 1 < _col && _pMaze[i][j + 1]._val == 0)
					_pMaze[i][j]._state[0] = 0;
				if (i-1>=0&&_pMaze[i - 1][j]._val == 0)
					_pMaze[i][j]._state[3] = 0;
				if (j-1>=0&&_pMaze[i][j - 1]._val == 0)
					_pMaze[i][j]._state[2] = 0;
				if (i+1<_row&&_pMaze[i + 1][j]._val == 0)
					_pMaze[i][j]._state[1] = 0;
			}
		}
	}

	void searchMazePath()
	{
		int i = 0, j = 0;
		_stack.push(this->_pMaze[i][j]);
		while (!_stack.empty())
		{
			Node tmp = _stack.top();
			i = tmp._x;
			j = tmp._y;
			if (i == _row - 1 && j == _col - 1)
				break;
			if (_pMaze[i][j]._state[0] == 0)//右
			{
				_pMaze[i][j]._state[0] = 1;
				_stack.push(_pMaze[i][j + 1]);
				_pMaze[i][j + 1]._state[2] = 1;
				continue;
			}
			else if (_pMaze[i][j]._state[1] == 0)//下
			{
				_pMaze[i][j]._state[1] = 1;
				_stack.push(_pMaze[i + 1][j]);
				_pMaze[i + 1][j]._state[3] = 1;
				
				continue;
			}
			else if (_pMaze[i][j]._state[2] == 0)//左
			{
				_pMaze[i][j]._state[2] = 1;
				_stack.push(_pMaze[i][j - 1]);
				_pMaze[i][j - 1]._state[0] = 1;
				continue;
			}
			else if (_pMaze[i][j]._state[3] == 0)//上
			{
				_pMaze[i][j]._state[3] = 1;
				_stack.push(_pMaze[i - 1][j]);
				_pMaze[i - 1][j]._state[1] = 1;
				continue;
			}
			_stack.pop();
		}
	}
	void showMazePath()
	{
		if (_stack.empty())
		{
			cout << "不存在一条迷宫路径！" << endl;
			return;
		}
		SetYesPMaze();
		for (int i = 0; i < _row; i++)
		{
			for (int j = 0; j < _col; j++)
			{
				if (_pMaze[i][j]._yes)
					cout << "* ";
				else
					cout << _pMaze[i][j]._val << " ";
			}
			cout << endl;
		}
		
	}
	void SetYesPMaze()
	{
		while (!_stack.empty())
		{
			Node tmp = _stack.top();
			_pMaze[tmp._x][tmp._y]._yes = true;
			_stack.pop();
		}
	}
private:
	Node **_pMaze;
	int _row;
	int _col;
	SeqStack _stack; // 组合
};

int main()
{
	cout << "请输入迷宫的行列数(例如：10 10):";
	int row, col, data;
	cin >> row >> col;

	Maze maze(row, col); // 创建迷宫对象

	cout << "请输入迷宫的路径信息(0表示可以走，1表示不能走):" << endl;
	for (int i = 0; i < row; ++i)
	{
		for (int j = 0; j < col; ++j)
		{
			cin >> data;
			// 可以初始化迷宫节点的基本信息
			maze.initNode(i, j, data);
		}
	}

	// 开始设置所有节点的四个方向的状态
	maze.setNodeState();

	// 开始从左上角搜索迷宫的路径信息了
	maze.searchMazePath();

	// 打印迷宫路径搜索的结果
	maze.showMazePath();

	getchar();

	return 0;
}
/*
0 0 1 1 1 1
1 0 0 0 0 1
1 0 1 1 0 1
1 0 0 0 0 1
1 0 1 1 1 1
1 0 0 0 0 0

*/

深度搜索的缺点在于不能找到一条最优的路径如代码最后给出的例子中的解法答案便是

* * 1 1 1 1
1 * * * * 1
1 0 1 1 * 1
1 * * * * 1
1 * 1 1 1 1
1 * * * * *

这条路径很明显不是最优的路径。

这里我们便需要广度搜索路径了。