迷宫问题问题描述：
栈的实现在这篇博客中：https://blog.csdn.net/zj1131190425/article/details/87991662
迷宫是一个矩形区域，有一个出口和入口，迷宫内部包含不能穿越的墙壁和障碍物。
1.用矩阵来描述迷宫。入口是(0, 0), 出口是(m,n)，现在需要在迷宫中选找一条路径，穿过迷宫。位置(i,j)=1表示有障碍。0表示无障碍。
思路：
1.出发点处，定义四个方向的坐标偏移量，搜索等四个方向，直到找到一个可行的方向，按照可行的方向移动到下一个位置，将前一个位置坐标压入栈中（保存路径），且将此位置设置为1（放置障碍物，防止往回退的时候又重新搜索这个方向）
2. 如果在某个位置没有找到可行的方向，则将当前这个位置设置为1（这个位置不可再回来），从栈顶弹出一个坐标，作为当前坐标（相当于走回头路），继续搜索其他的方向是否可行。
3. 如此往复
采用自顶向下设计的方法设计代码：
（1）输入迷宫
（2）寻找路径
（3）输出路径
#include <iostream>
#include "E:\back_up\code\c_plus_code\sparseMatrix\external_file\arraystack.h"
#include <string>
using namespace std;
// 迷宫
template<typename T>
void print_array(T a[][12])
{
for(int i=0; i<12; i++)
{
for(int j=0; j<12; j++)
{
cout << a[i][j] << " ";
}
cout << endl;
}
cout << endl;
}
class position // 存储位置坐标
{
public:
int row;
int col;
position()
{
row = 0;
col = 0;
}
position(int row, int col)
{
this->row = row;
this->col = col;
}
void add_offset(position& ps)
{
row += ps.row;
col += ps.col;
}
};
void find_path(bool map[][12])
{
int map_1[12][12];
// 保存map()的一个副本
for(int i=0; i<12; i++)
{
for(int j=0; j<12; j++)
{
map_1[i][j] = (int)map[i][j];
}
}
// 寻找迷宫的路径
arrayStack<position> path; // 存储路径信息
// 偏移量
position offset[4];
// 向右偏移 index=0
offset[0].row = 0;
offset[0].col = 1;
// 向下偏移 index=1
offset[1].row = 1;
offset[1].col = 0;
// 向左偏移 index=2
offset[2].row = 0;
offset[2].col = -1;
// 向上偏移 index=3
offset[3].row = -1;
offset[3].col = 0;
position current_position(1,1); // 初始化当前位置
int option = 0; //初始化选的方向，右，下，左，上=(0,1,2,3)
int max_otion = 3; // 方向的选择范围
map[1][1] = 1; // 在(1,1)位置放置障碍
cout << "current position: " << current_position.row << " " << current_position.col << endl;
while(current_position.row!=10 || current_position.col!=10)
{
int r,c;
while(option<=max_otion)
{
r = current_position.row + offset[option].row;
c = current_position.col + offset[option].col;
if(map[r][c]==0) // 新的位置可行
{
break;
}
option++;
}
if(option<=max_otion) // 找到了可行的方向
{
path.push(current_position);
//current_position.add_offset(offset[position]); // current_position更新
current_position.row = r; // 移动到新的位置
current_position.col = c;
map[r][c] = 1; // 放置障碍物 避免回退时又选到这个方向
option = 0;
}
else // 选择的位置走不通
{
if(path.empty())
{
cout << "The puzzle has no solution" << endl;
return;
}
position next = path.top();
path.pop();
// 计算返回后的搜索方向：
// 按照前面对方向的定义，返回后应该搜索未搜索过的两个方向：
// map[currentRow][currentCol] = 1; // 走不通的位置设置障碍，避免重复搜索
map[current_position.row][current_position.col] = 1; // 当前的位置是死路
option = 0;
current_position = next; // 浅复制即可 这个类默认的拷贝构造函数
}
cout << "(r,c)= " << r << "," << c << endl;
}
position tmp;
while(!path.empty())
{
// cout << "revise the map" << endl;
tmp = path.top();
path.pop();
map_1[tmp.row][tmp.col] = 2;
}
// 结果输出
char result[12][12];
for(int i=0; i<12; i++)
{
for(int j=0; j<12; j++)
{
if(map_1[i][j]==1)
{
result[i][j]='1';
}
else if(map_1[i][j]==0)
{
result[i][j]='0';
}
else
{
result[i][j]='*';
}
}
}
print_array(result);
}
int main(int argc, char *argv[])
{
//int a[12][12];
bool a[][12] = {
{1,1,1,1,1,1,1,1,1,1,1,1},
{1,0,1,1,1,1,1,0,0,0,0,1},
{1,0,0,0,0,0,1,0,1,0,0,1},
{1,0,0,0,1,0,1,0,0,0,0,1},
{1,0,1,0,1,0,1,0,1,1,0,1},
{1,0,1,0,1,0,1,0,1,0,0,1},
{1,0,1,1,1,0,1,0,1,0,1,1},
{1,0,1,0,0,0,1,0,1,0,1,1},
{1,0,1,0,1,1,1,0,1,0,0,1},
{1,1,0,0,0,0,0,0,1,0,0,1},
{1,0,0,0,0,1,1,1,1,0,0,1},
{1,1,1,1,1,1,1,1,1,1,1,1}
};
//print_array(a);
find_path(a);
return 0;
}
运行结果：
迷宫问题最短路径
可以使用队列来实现寻找最短路径的操作
首先介绍C++ 实现队列：关于队列的实现参考博客： https://blog.csdn.net/zj1131190425/article/details/88090905，下面的队列是对https://blog.csdn.net/zj1131190425/article/details/88090905中队列的改进，主要是改经了ensureCapacity()函数，因为原来的队列中ensureCapacity()函数有点小的bug.
定义一个队列的基类，queueABC
queueABC.h文件
#ifndef QUEUE_ABC_H
#define QUEUE_ABC_H
using namespace std;
// 定义抽象类
template<typename T>
class queueABC
{
public:
// virtual ~queue();
virtual bool empty() const=0; // 纯虚函数 只读
virtual int size() const=0; // 返回队列中元素的个数
virtual T& front() = 0; // 返回队首元素
virtual T& back() = 0; // 返回队尾元素
virtual void pop() = 0; // 删除队首的元素
virtual void push(T x) = 0; // 队尾插入元素
};
#endif
queue.h
#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
#include <algorithm>
#include "E:\back_up\code\c_plus_code\dequeue\external_file\queueABC.h" // 包含ABC文件
#include "E:\back_up\code\c_plus_code\dequeue\external_file\queueemptyEx.h" // 包含异常类文件
using namespace std;
template<typename T>
class queue : public queueABC<T>
{
private:
int arrayLength; // 数组的长度
int queueSize; // 队列中元素的个数
int queueFront; // 队首元素所在的位置
int queueBack; // 队尾元素所在的位置
T* element;
void ensureArrayLength(); // 进行数组扩容
public:
queue(int arrayLength=10); // 构造函数
~queue(); // 析构函数
queue(const queue& q); // 拷贝构造函数
// ADT
bool empty() const;
int size() const;
T& front();
T& back();
void pop();
void push(T x);
void display_queue() const; // 打印输出队列中的元素
};
template<typename T>
queue<T>::queue(int arrayLength)
{
this->arrayLength = arrayLength;
this->queueSize = 0;
this->queueFront = 0;
this->queueBack = 0;
element = new T[arrayLength];
}
template<typename T>
queue<T>::~queue()
{
delete [] element;
}
template<typename T>
queue<T>::queue(const queue& q)
{
arrayLength = q.arrayLength;
queueSize = q.queueSize;
queueFront = q.queueFront;
queueBack = q.queueBack;
element = new T[arrayLength];
for(int i=0; i<queueSize; i++)
{
element[i] = q.element[i];
}
}
template<typename T>
bool queue<T>::empty() const
{
return queueSize==0;
}
template<typename T>
int queue<T>::size() const
{
return queueSize;
}
template<typename T>
T& queue<T>::front()
{
return element[(queueFront+1)%arrayLength]; // queueFront是队首元素的前一个位置，+1是表示队首元素的位置
}
template<typename T>
T& queue<T>::back()
{
return element[queueBack%arrayLength]; // queueback队尾元素的位置
}
/*
template<typename T>
void queue<T>::ensureArrayLength()
{
// 如果需要，增加数组长度
if((queueBack+1)%arrayLength==queueFront) // 环形的数组
{
T* old;
old = element;
//delete element;
// arrayLength = arrayLength*2; // 增加分配的内存长度
element = new T[2*arrayLength];
// 环形数组重新布局
// 先将数组复制过来
//更新关于数组复制
int index_tmp;
for(int i=0; i<queueSize; i++)
{
index_tmp = (queueFront+1+i)%arrayLength;
element[index_tmp] = old[index_tmp];
}
delete old;
// 重新布局 // 分为三种情况：1.queuefront=0; queuefront==arrayLength-1; else;
int pre_start = queueFront%arrayLength; // 队列首元素的前一个位置
if(pre_start==0)
{
// 移动所有的数组元素
for(int i=0; i<queueSize; i++)
{
element[2*arrayLength-1-i] = element[(queueBack%arrayLength)-i];
}
queueFront = queueFront + arrayLength;
queueBack = queueBack + arrayLength;
}
else if(pre_start==arrayLength-1) // arrayLength还是原来的值
{
// 不用移动数组元素,之更改front
queueFront = queueFront + arrayLength;
}
else
{
// 移动第二段的元素：
int element_to_move = arrayLength-1-(queueFront%arrayLength); // 计算第二段需要移动的元素的数量
for(int i=0; i<element_to_move; i++)
{
element[2*arrayLength-1-i] = element[queueBack%arrayLength-i];
}
queueFront = queueFront + arrayLength;
}
arrayLength = arrayLength*2; // 更新arrayLength
}
// 添加一个动态减少内存的函数
}
*/
template<typename T>
void queue<T>::ensureArrayLength()
{
if((queueBack+1)%arrayLength==queueFront) // 环形的数组
{
T* new_element = new T[2*arrayLength];
int start = (queueFront+1)%arrayLength;
if(start<2) // 没有形成环
{
copy(element+start, element+start+arrayLength-1, new_element); // 复制操作
}
else // 形成环
{
copy(element+start, element+arrayLength, new_element);
copy(element, element+queueBack+1, new_element+arrayLength-start);
}
queueFront = 2*arrayLength-1;
queueBack = arrayLength-2;
arrayLength *= 2;
delete[] element;
element = new_element;
}
}
// push()操作：
template<typename T>
void queue<T>::push(T x)
{
ensureArrayLength(); // 先保证数组长度满足条件
queueSize++;
//queueBack = (queueBack+1)%arrayLength;
//element[queueBack] = x;
queueBack++;
element[queueBack%arrayLength] = x;
}
//pop()操作
template<typename T>
void queue<T>::pop()
{
if(empty())
throw queueEmptyException(0);
queueFront++;
queueSize--;
// element[queueFront].~T;
}
template<typename T>
void queue<T>::display_queue() const
{
//int tmp = queueFront;
// int start_pos = (tmp+1)%arrayLength;
if(empty())
{
cout << "The queue is empty!" << endl;
return;
}
for(int i=0; i<queueSize; i++)
{
cout << element[(queueFront+1+i)%arrayLength] << " ";
}
cout << endl;
}
#endif 自定义的异常类：
queueemptyException:
// 自定义异常类
#ifndef QUEUE_EMPTY_EXCEPTION
#define QUEUE_EMPTY_EXCEPTION
#include <stdexcept>
#include <iostream>
using namespace std;
class queueEmptyException : public runtime_error
{
private:
int queueSize;
public:
queueEmptyException(int queueSize) : runtime_error("The queue empty!")
{
this->queueSize = queueSize;
}
void display_error_info()
{
cout << "The queue size is " << queueSize << endl;
}
};
#endif寻找最短路径的算法思路：
从上面的迷宫中，找一条从入口到出口的最短路径，要有两个过程:
1. 一个是距离标记过程
2. 另一个是路径标记过程
在距离标记过程中，把能从入口到达的相邻位置标记为1，然后把从编号为1可到达的相邻位置标记为2（表示与入口相距为2），直到到达出口或者没有可标记的相邻位置为止。
在路径标记过程中，从出口开始，首先移动到比出口的编号小1的位置，再从当前位置移动到比其编号小1的位置上，直到到达起点为止，这便是最短的路径
3.按照上述思路编写代码实现：
main.cpp
#include <iostream>
#include "E:\back_up\code\c_plus_code\dequeue\external_file\queue.h"
using namespace std;
// 迷宫
template<typename T>
void print_array(T **a, int size)
{
for(int i=0; i<size; i++)
{
for(int j=0; j<size; j++)
{
cout << a[i][j] << " ";
}
cout << endl;
}
cout << endl;
}
class position // 存储位置坐标
{
public:
int row;
int col;
position()
{
row = 0;
col = 0;
}
position(int row, int col)
{
this->row = row;
this->col = col;
}
/*
void add_offset(position& ps)
{
row += ps.row;
col += ps.col;
}
*/
};
void findPath(int** map, int mapSize=10)
{
// 这里默认起始点为(0,0),终点为(9,9)
// 给地图添加围墙：
int** new_map = new int*[mapSize+2];
for(int i=0; i<mapSize+2; i++)
{
new_map[i] = new int[mapSize+2];
}
for(int i=0; i<mapSize+2; i++)
{
for(int j=0; j<mapSize+2; j++)
{
if(i==0 || i==mapSize+2-1)
{
new_map[i][j] = 1; // 增加行围墙
}
else if(j==0 || j==mapSize+2-1) //增加列围墙
{
new_map[i][j] = 1;
}
else // 保存地图
{
new_map[i][j] = map[i-1][j-1];
}
}
}
// print_array(map, mapSize);
cout << "原始地图： " << endl;
print_array(new_map, mapSize+2);
// 初始化偏移量
position offset[4];
// 向右偏移 index=0
offset[0].row = 0;
offset[0].col = 1;
// 向下偏移 index=1
offset[1].row = 1;
offset[1].col = 0;
// 向左偏移 index=2
offset[2].row = 0;
offset[2].col = -1;
// 向上偏移 index=3
offset[3].row = -1;
offset[3].col = 0;
position current_position(1,1); // 初始化当前位置
position end_position(10,10);
new_map[current_position.row][current_position.col] = 2; // 这里距离标记从2开始，实际距离等于标号-2
int direction_number = 4; // 一个方格相邻位置的个数
position neighbor;
queue<position> q; // 队列，用于存放标记的位置
while(true)
{
// 给相邻位置做标记
for(int i=0; i<direction_number; i++)
{
neighbor.row = current_position.row + offset[i].row;
neighbor.col = current_position.col + offset[i].col;
if(new_map[neighbor.row][neighbor.col]==0) // 可标记的位置
{
new_map[neighbor.row][neighbor.col] = new_map[current_position.row][current_position.col]+1; // 标记
if(neighbor.row==end_position.row && neighbor.col==end_position.col)
{
break; // 标记完成
}
q.push(neighbor);
}
}
if(neighbor.row==end_position.row && neighbor.col==end_position.col)
{
break; // 到达
}
if(q.empty()) // 迷宫无解；
{
cout << "The puzzle has no solution" << endl;
return;
}
current_position = q.front();
q.pop();
}
//cout << "标记完的矩阵： " << endl;
//print_array(new_map, 12);
// 构造路径；
int pathLength = new_map[end_position.row][end_position.col]-2; // 路径的长短
// position* path = new position[pathLength];
queue<position> q_path; // 存储路径
current_position = end_position; // 从终点回溯
for(int i=pathLength-1; i>=0; i--)
{
// path[i] = current_position;
q_path.push(current_position); // 当前的位置放入队列中
for(int j=0; j<direction_number; j++)
{
neighbor.row = current_position.row + offset[j].row;
neighbor.col = current_position.col + offset[j].col;
if(new_map[neighbor.row][neighbor.col] == i+2)
{
break;
}
}
//测试
// cout << "current position: " << current_position.row << ',' << current_position.col << endl;
current_position = neighbor;
}
/* 测试代码
position tmp;
while(!q_path.empty())
{
tmp = q_path.front();
cout << "path: " << tmp.row << "," << tmp.col << endl;
q_path.pop();
}
*/
/* 测试代码
for(int i=0; i<pathLength; i++)
{
cout << "path: " << path[i].row << "," << path[i].row << endl;
}
*/
// 输出结果
char** result = new char*[mapSize+2]; // 创建一个新的矩阵保存可视化结果
for(int i=0; i<mapSize+2; i++)
{
result[i] = new char[mapSize+2];
}
// 初始化：
position tmp;
while(!q_path.empty())
{
tmp = q_path.front();
result[tmp.row][tmp.col] = '*';
q_path.pop();
}
for(int i=0; i<mapSize+2; i++)
{
for(int j=0; j<mapSize+2; j++)
{
if(result[i][j] != '*' && new_map[i][j]==1)
{
result[i][j] = '1';
}
if(result[i][j] != '*' && (new_map[i][j]==0 || new_map[i][j]>1))
{
result[i][j] = '0';
}
}
}
// 输出迷宫路径
cout << "最短路径： " << pathLength << endl;
cout << "迷宫路径如下所示： " << endl;
print_array(result, mapSize+2);
}
int main(int argc, char *argv[])
{
int map_size = 10;
int input_map[10][10] = {
{0,1,1,1,1,1,0,0,0,0},
{0,0,0,0,0,1,0,1,0,0},
{0,0,0,1,0,1,0,0,0,0},
{0,1,0,1,0,1,0,1,1,0},
{0,1,0,1,0,1,0,0,0,0},
{0,1,0,0,0,1,0,1,0,1},
{0,1,0,0,0,1,0,1,0,1},
{1,0,0,0,0,0,0,1,0,0},
{0,0,0,0,1,1,1,1,0,0}
};
// 数据转换
int** map_in = new int*[map_size];
for(int i=0; i<map_size; i++)
{
map_in[i] = new int[map_size];
}
for(int i=0; i<map_size; i++)
{
for(int j=0; j<map_size; j++)
{
map_in[i][j] = input_map[i][j];
}
}
// 将原始地图转换为指针的形式
findPath(map_in, map_size);
return 0;
}
算法的运行结果如下图所示：
---------------------------------------------------end----------------------------------------------------------