@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;
}

迷宫最短路径问题

一.迷宫最短路径问题

1. 整体过程

1.minpath与path之间不能直接拷贝(浅拷贝问题)

2.找到一次通路后，如何处置已经变为2的路径

3. getmazepath不需要判断是否为真

4.整体代码

热门文章

最新文章

相关电子书