@TOC
一.迷宫最短路径问题
小青蛙有一天不小心落入了一个地下迷宫,小青蛙希望用自己仅剩的体力值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!"。 测试数据保证答案唯一
示例1
输入：
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]
原题来自于：来自于牛客网的地下迷宫
这道题跟常规迷宫问题大体相似，只不过引入了体力值的消耗问题
相比较上次的常规迷宫问题，这次的1是通路 ，0是墙壁
1. 整体过程
这里前面的过程就不说了，需要的可以看：迷宫常规问题
主要从找到通路后，回溯后走到另一条路开始
在这里插入图片描述
在这里插入图片描述1.此时走到下标(0,3)时找到出口， 回溯时发现只有达到下标(2,2)时 ，右方向可以走，2. 因为我们遵循 上下左右 四个方向依次递归，所以是当下标(2,2)完成了下的递归 回溯后，只有左右两个方向可以走
在这里插入图片描述
当此次完成后的路径path与minpath最短路径比较，发现此时为最短路径。
1.minpath与path之间不能直接拷贝(浅拷贝问题)
path 作为当前路径，minpath作为最短路径，当path值小于minpath值时，需要把path值赋值给minpath，但是如果我们此时单纯赋值处理的话会出现问题
在这里插入图片描述1. 把path赋值给minpath，此时的minpath原来的空间就丢了，造成内存泄漏2. 此时的赋值是将minpath指向path的空间，因为两者都需要内存销毁，就会导致内存销毁两次
所以为了防止这种情况的发生
将minpath原有的空间销毁掉，再动态开辟一块跟path相同大小的空间，并将path的值拷贝过来
在这里插入图片描述
void stackcopy(ST* minpath, ST* path) { minpath->a = (datatype*)malloc(sizeof(datatype*) * path->capacity);//动态开辟一块与path一样大的空间 memcpy(minpath->a, path->a, sizeof(datatype) * path->top);//使用内存拷贝函数将path的内容拷贝过来 minpath->top = path->top; minpath->capacity = path->capacity; }
2.找到一次通路后，如何处置已经变为2的路径
在回溯的过程中，把变成2的通路置成1
回溯的判断:如果上下左右四个方向都不可以走，就回溯。
如图此时寻找到出口后，先将出口下标置成2，再判断此时上下左右都不能走，在回溯到上一层之前，才把出口下标置成1
在这里插入图片描述
在这里插入图片描述
3. getmazepath不需要判断是否为真
在常规迷宫问题中只要找到通路就可以了，但是在 最短路径中，我们需要考虑到所有情况，
每次找到通路的path 与minpath值比较 ，找到最短路径，
加true 用于只判断一次通路的情况，不加true可以判断所有通路的情况
ST path; ST minpath; void stackcopy(ST* minpath, ST* path) { minpath->a = (datatype*)malloc(sizeof(datatype*) * path->capacity); memcpy(minpath->a, path->a, sizeof(datatype) * path->top); minpath->top = path->top; minpath->capacity = path->capacity; } void getmazepath(int** maze, int N, int M, PT cur,int p) { stackpush(&path, cur);//入栈 if (cur.row == 0 && cur.col == M - 1)//出口 { //找到最短路径，更新minpath 要保证体力>=0 if (p >= 0 && stackempty(&minpath) || stacksize(&path) < stacksize(&minpath)) { stackdestroy(&minpath); stackcopy(&minpath, &path);//将path赋给minpath } } maze[cur.row][cur.col] = 2;//先将目前所处位置赋值为2 PT next; next = cur;//上 next.row -= 1; if (ispass(maze, N, M, next))//判断上的位置是否满足继续的条件 { getmazepath(maze, N, M, next,p-3); } next = cur;//下 next.row += 1; if (ispass(maze, N, M, next))//判断下的位置是否满足继续的条件 { getmazepath(maze, N, M, next,p); } next = cur;//左 next.col -= 1; if (ispass(maze, N, M, next))//判断左的位置是否满足继续的条件 { getmazepath(maze, N, M, next,p-1); } next = cur;//右 next.col += 1; if (ispass(maze, N, M, next))//判断右的位置是否满足继续的条件 { getmazepath(maze, N, M, next,p-1); } maze[cur.row][cur.col] = 1;//恢复公共路径 stackpop(&path); //如果上下左右都不满足就移除栈顶元素 }
4.整体代码
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #include<assert.h> #include<string.h> typedef struct postion { int row;//行 int col;//列 }PT; ///////////////////////////////////////// typedef PT datatype;//将数据类型改为结构体 typedef struct stack { datatype* a; int top; int capacity; }ST; void stackinit(ST* p); void stackpush(ST* p, datatype x); datatype stacktop(ST* p); void stackpop(ST* p); int stacksize(ST* p); bool stackempty(ST* p); void stackdestroy(ST* p); //////////////////////////////////////// void stackinit(ST* p)//栈的初始化 { assert(p); p->a = NULL; p->top = 0; p->capacity = 0; } void stackpush(ST* p, datatype x)//入栈 { assert(p); if (p->top == p->capacity) { int newcapacity = p->capacity == 0 ? 4 : 2 * p->capacity; datatype* tmp = (datatype*)realloc(p->a, sizeof(datatype) * newcapacity); if (tmp != NULL) { p->a = tmp; p->capacity = newcapacity; } } p->a[p->top] = x; p->top++; } void stackpop(ST* p)//移除栈顶元素 { assert(p); assert(p->top > 0); p->top--; } datatype stacktop(ST* p)//出栈 { assert(p); assert(p->top > 0); return p->a[p->top - 1]; } bool stackempty(ST* p)//是否为空 { return p->top == 0; } int stacksize(ST* p)//栈中元素个数 { assert(p); return p->top; } void stackdestroy(ST* p)//内存销毁 { assert(p); free(p->a); p->a = NULL; p->top = 0; p->capacity = 0; } /// /////////////////////////////////////// bool ispass(int** maze, int N, int M, PT pos)//现在为1为通道，0为墙壁 { if (pos.row >= 0 && pos.row < N && pos.col >= 0 && pos.col < M && maze[pos.row][pos.col] == 1) { //坐标不越界并且该处位置==1 return true; } else { return false; } } ST path; ST minpath; void stackcopy(ST* minpath, ST* path) { minpath->a = (datatype*)malloc(sizeof(datatype*) * path->capacity); memcpy(minpath->a, path->a, sizeof(datatype) * path->top); minpath->top = path->top; minpath->capacity = path->capacity; } void getmazepath(int** maze, int N, int M, PT cur,int p) { stackpush(&path, cur);//入栈 if (cur.row == 0 && cur.col == M - 1)//出口 { //找到最短路径，更新minpath 要保证体力>=0 if (p >= 0 && stackempty(&minpath) || stacksize(&path) < stacksize(&minpath)) { stackdestroy(&minpath); stackcopy(&minpath, &path);//将path赋给minpath } } maze[cur.row][cur.col] = 2;//先将目前所处位置赋值为2 PT next; next = cur;//上 next.row -= 1; if (ispass(maze, N, M, next))//判断上的位置是否满足继续的条件 { getmazepath(maze, N, M, next,p-3); } next = cur;//下 next.row += 1; if (ispass(maze, N, M, next))//判断下的位置是否满足继续的条件 { getmazepath(maze, N, M, next,p); } next = cur;//左 next.col -= 1; if (ispass(maze, N, M, next))//判断左的位置是否满足继续的条件 { getmazepath(maze, N, M, next,p-1); } next = cur;//右 next.col += 1; if (ispass(maze, N, M, next))//判断右的位置是否满足继续的条件 { getmazepath(maze, N, M, next,p-1); } maze[cur.row][cur.col] = 1;//恢复公共路径 stackpop(&path); //如果上下左右都不满足就移除栈顶元素 } void printpath(ST* ps)//由于此时的path栈要打印出来会倒着出， //所以又重新创建了一个栈，将数据导进去 { ST rpath; stackinit(&rpath); while (!stackempty(ps)) { stackpush(&rpath, stacktop(ps)); stackpop(ps); } while (stacksize(&rpath)>1) { PT top = stacktop(&rpath);//此时数据类型被改为PT printf("[%d,%d],", top.row, top.col); stackpop(&rpath); } PT top = stacktop(&rpath);//此时数据类型被改为PT printf("[%d,%d]", top.row, top.col); stackpop(&rpath); stackdestroy(&rpath);//内存销毁 } int main() { int N = 0; int M = 0; int p = 0; while (scanf("%d%d%d", &N, &M,&p) != EOF)//多组输入 { //动态开辟二维数组 //1.开辟N个指针数组 int** maze = (int**)malloc(sizeof(int*) * N); //2.开辟M个空间 int i = 0; for (i = 0; i < N; i++) { maze[i] = (int*)malloc(sizeof(int) * M); } int j = 0; for (i = 0; i < N; i++) { for (j = 0; j < M; j++) { scanf("%d", &maze[i][j]); } } PT entry = { 0,0 }; stackinit(&path); stackinit(&minpath); getmazepath(maze, N, M, entry, p); if (!stackempty(&minpath))//如果最短路径因为体力问题为0 { printpath(&minpath); } else { printf("Can not escape!"); } stackdestroy(&path); stackdestroy(&minpath); //释放空间 //1.释放N个数组指针指向的空间 for (i = 0; i < N; i++) { free(maze[i]); } //2.将N个指针数组整体释放 free(maze); maze = NULL; } return 0; }
