迷宫问题打印路径1

定义一个二维数组 N*M ，如 5 × 5 数组下所示：

int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。

输入描述：
输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

输出描述：
左上角到右下角的最短路径
输入：
5 5
0 1 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出：
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

思路

定义一个结构体

typedef struct pt {//行·int row;//列int col;
}PT;

要保存所走的路径，就需要使用到栈

  导入c++的 STL栈。
如果是c语言就需要自己手写栈。
c语言的栈

遍历所有的可能性

核心代码

  遍历上，右，左，下四个方向。先上核心代码。

bool isPath(int** a, int n, int m, PT pt)
{if (pt.row >= 0 && pt.row < n&& pt.col >= 0 && pt.col < m&& a[pt.row][pt.col] == 0){return true;}else {return false;}
}//这里只需要一条路，直接返回bool值
bool dfs(int** a, int n, int m, PT pt)
{st.push(pt);if (pt.row == n - 1 && pt.col == m - 1){//找到出口return true;}//标记走过的路为2a[pt.row][pt.col] = 2;//开始遍历四个方向//上PT next = pt;next.row -= 1;if (isPath(a, n, m, next)){if (dfs(a, n, m, next)){return true;}}//右next.row += 1;next.col += 1;if (isPath(a, n, m, next)){if (dfs(a, n, m, next)){return true;}}//下next.col -= 1;next.row += 1;if (isPath(a, n, m, next)){if (dfs(a, n, m, next)){return true;}}//左next.row -= 1;next.col -= 1;if (isPath(a, n, m, next)){if (dfs(a, n, m, next)){return true;}}st.pop();//四个方向都不行，则false;return false;
}

部分函数递归图

开始按照每个点的上，右，左，下开始前进，如果可以走，则进行标记为2，如果一个方向不可以走，则换另一个方向，直到四个方向都不可以走，则返回上一个正确的位置。

源代码

// https://www.nowcoder.com/practice/cf24906056f4488c9ddb132f317e03bc?tpId=37&tqId=21266&ru=/exam/oj#include <iostream>
using namespace std;
#include<stack>typedef struct pt {int row;int col;
}PT;stack<PT> st;bool isPath(int** a, int n, int m, PT pt)
{if (pt.row >= 0 && pt.row < n&& pt.col >= 0 && pt.col < m&& a[pt.row][pt.col] == 0){return true;}else {return false;}
}//这里只需要一条路，直接返回bool值
bool dfs(int** a, int n, int m, PT pt)
{st.push(pt);if (pt.row == n - 1 && pt.col == m - 1){//找到出口return true;}a[pt.row][pt.col] = 2;//开始遍历四个方向//上PT next = pt;next.row -= 1;if (isPath(a, n, m, next)){if (dfs(a, n, m, next)){return true;}}//右next.row += 1;next.col += 1;if (isPath(a, n, m, next)){if (dfs(a, n, m, next)){return true;}}//下next.col -= 1;next.row += 1;if (isPath(a, n, m, next)){if (dfs(a, n, m, next)){return true;}}//左next.row -= 1;next.col -= 1;if (isPath(a, n, m, next)){if (dfs(a, n, m, next)){return true;}}st.pop();//四个方向都不行，则false;return false;
}void Print(stack<PT> st)
{stack<PT> rt;while (!st.empty()){rt.push(st.top());st.pop();}while (!rt.empty()){cout << "(" << rt.top().row << "," << rt.top().col << ")" << endl;rt.pop();}
}int main() {int n, m;while (cin >> n >> m) { // 注意 while 处理多个 case//开辟一个动态二维数组int** tmp = (int**)malloc(sizeof(int*) * n);for (int i = 0; i < n; ++i){tmp[i] = (int*)malloc(sizeof(int) * m);}for (int i = 0; i < n; ++i){for (int j = 0; j < m; ++j){cin >> tmp[i][j];}}//定义结构体PT pt;pt.row = 0;pt.col = 0;bool flag = dfs(tmp, n, m, pt);if (flag == true){Print(st);}}}

迷宫问题返回最短路径

描述
小青蛙有一天不小心落入了一个地下迷宫,小青蛙希望用自己仅剩的体力值P跳出这个地下迷宫。为了让问题简单,假设这是一个n*m的格子迷宫,迷宫每个位置为0或者1,0代表这个位置有障碍物,小青蛙达到不了这个位置;1代表小青蛙可以达到的位置。小青蛙初始在(0,0)位置,地下迷宫的出口在(0,m-1)(保证这两个位置都是1,并且保证一定有起点到终点可达的路径),小青蛙在迷宫中水平移动一个单位距离需要消耗1点体力值,向上爬一个单位距离需要消耗3个单位的体力值,向下移动不消耗体力值,当小青蛙的体力值等于0的时候还没有到达出口,小青蛙将无法逃离迷宫。现在需要你帮助小青蛙计算出能否用仅剩的体力值跳出迷宫(即达到(0,m-1)位置)。
输入描述：
输入包括n+1行:
第一行为三个整数n,m(3 <= m,n <= 10),P(1 <= P <= 100)
接下来的n行:
每行m个0或者1,以空格分隔
输出描述：
如果能逃离迷宫,则输出一行体力消耗最小的路径,输出格式见样例所示;如果不能逃离迷宫,则输出"Can not escape!"。 测试数据保证答案唯一
输入4 4 10 1 0 0 1 1 1 0 1 0 1 1 1 0 0 1 1
[0,0],[1,0],[1,1],[2,1],[2,2],[2,3],[1,3],[0,3]

这里的思想同上面类似。

  但是也有略微区别，这里要求最短路径，我们怎么知道求出的答案就是最短的路劲呢？所以这里要遍历所有可以前进的路线。走的路径进行标记，不走的路劲标记过的要取消标记。

源代码

#include <iostream>
using namespace std;
#include<stack>//定义坐标typedef struct pt {int row;int col;
}PT;//普通路径
stack<PT> st;
//最短路径
stack<PT> minSt;//判断能否通过
bool isPath(int** tmp, int n, int m, PT pt)
{if (pt.row >= 0 && pt.row < n&& pt.col >= 0 && pt.col < m&& tmp[pt.row][pt.col] == 1){return true;}else {return false;}
}//这里我们要找到·所有路径，所以不用返回
void dfs(int** tmp, int n, int m, PT pt, int p)
{//每次进来先入栈st.push(pt);//走过的路标记为2tmp[pt.row][pt.col] = 2;if (p >= 0 && pt.row == 0 && pt.col == m - 1){//更新最短路径if (st.size() < minSt.size() ||minSt.empty()){minSt = st;}}//枚举所有方法PT next;//上next = pt;next.row -= 1;if (isPath(tmp, n, m, next)){dfs(tmp, n, m, next, p - 3);}//右next = pt;next.col += 1;if (isPath(tmp, n, m, next)){dfs(tmp, n, m, next, p - 1);}//下next = pt;next.row += 1;if (isPath(tmp, n, m, next)){dfs(tmp, n, m, next, p);}//左next = pt;next.col -= 1;if (isPath(tmp, n, m, next)){dfs(tmp, n, m, next, p - 1);}//都不能走，还原路径为1tmp[pt.row][pt.col] = 1;st.pop();//四个方向都不能走
}//进行对栈的打印
void Print(stack<PT> st)
{stack<PT> rt;while (!st.empty()){rt.push(st.top());st.pop();}while (rt.size() > 1){cout << "[" << rt.top().row << "," << rt.top().col << "]" << ",";rt.pop();}cout << "[" << rt.top().row << "," << rt.top().col << "]" << endl;rt.pop();
}int main() {int n, m, p;while (cin >> n >> m) { // 注意 while 处理多个 casecin >> p;//开辟二维数组int** tmp = (int**)malloc(sizeof(int*) * n);for (int i = 0; i < n; ++i){tmp[i] = (int*)malloc(sizeof(int) * m);}//输入for (int i = 0; i < n; ++i){for (int j = 0; j < m; ++j){cin >> tmp[i][j];}}PT pt;pt.row = 0;pt.col = 0;dfs(tmp, n, m, pt, p);if (!minSt.empty()){Print(minSt);}else {cout << "Can not escape!" << endl;}}
}