数据结构：各类迷宫问题详解(c语言版)

其他 2018-06-02 20:06:59 阅读次数: 0

第一类 简单迷宫（不含多条出路，不带环）（0代表墙，1代表通路）

这里写图片描述

思路分析：

1.以入口为起点，寻找出口（除了起点以外的边缘上的点）

2.判定当前点坐标是否可以走。（坐标合法且不为0）

3.如果合法则将当前点标记成走过的并入栈（维护一个栈可以记录走过的路径，栈的长度就是路径的长度）

4.判断当前点是否是出口，是出口就return（该迷宫不存在别的出口），如果不是出口，以顺时针的方向（上，右，下，###左）探测临界点是否可以走（不为0且不为已经走过的点），并以递归形式重复步骤2-4.

5.当一个点的4个方向都已经探测过，就返回上一层栈帧。

maze.h

#pragma once
#include<stdio.h>
#include<windows.h>
#include<assert.h>
//要定义的有：
//一个结构体为结构体pos，用于记录迷宫每个店的横纵坐标
//两个栈path和shortpath，记录通路的最短距离,栈内元素序列即是最短
//迷宫（迷宫地图，入口点）
#define N 6
#define Stack_size 20
typedef struct pos            //迷宫内每个点的坐标
{
    int row;
    int col;
}pos;

typedef pos DataType;

typedef struct Stack         //存放节点信息的栈
{
    DataType* _array;        //数组指针
    size_t  _top;            //栈顶 
    size_t  _end;            //最大容量
}Stack;

typedef struct maze          //迷宫
{
    int mz[N][N];
    pos entry;               //入口点
}maze;

function.h

#include"maze.h"

void StackInit(Stack* s)//栈的初始化
{
    assert(s);
    s->_array = (DataType*)malloc(sizeof(DataType)*Stack_size);
    s->_end = Stack_size;
    s->_top = 0;

}

void StackPush(Stack* s, DataType x)//入栈
{
    assert(s);
    if (s->_end == s->_top)//栈已满
    {
        s->_end *= 2;
        s->_array = (DataType*)realloc(s->_array, sizeof(DataType)*(s->_end));
        s->_array[s->_top] = x;
        (s->_top)++;
    }
    else
    {
        s->_array[s->_top] = x;
        (s->_top)++;
    }
}


void StackPop(Stack* s)//出栈
{
    assert(s);
    if (s->_top == 0)
    {
        printf("the stack is empty");
    }
    else
    {
        s->_top--;
    }
}

int StackEmpty(Stack* s)//判断栈是否为空
{
    if (s->_top == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

DataType StackTop(Stack* s)//取栈顶元素
{
    assert(s);


    int num = s->_top;
    DataType  i = s->_array[(--num)];
    return i;

}

void mazeinit(maze *M)//迷宫初始化
{
    assert(M);
    int a[N][N] = {
        { 0, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0 },
        { 0, 0, 1, 1, 1, 0 },
        { 0, 0, 1, 0, 1, 1 },
        { 0, 0, 1, 0, 0, 0 }
    };
    for (size_t i = 0;i < N;i++)
    {
        for (size_t j = 0;j < N;j++)
        {
            M->mz[i][j] = a[i][j];
        }
    }
    M->entry.row = 5;
    M->entry.col = 2;
}

void mazeprint(maze *M)
{
    assert(M);
    for (int i = 0;i < N;i++)
    {
        for (int j = 0;j < N;j++)
        {
            printf("%d  ", (M->mz)[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
int can_stay(pos cur, maze *M)//判断是否能入栈
{
    if (cur.row >= 0 && cur.row < N&&cur.col >= 0 && cur.col < N //坐标合法
        &&M->mz[cur.row][cur.col] != 0 && M->mz[cur.row][cur.col] != 2)   //该点不为墙也不为走过的点
    {
        return 1;
    }
    return 0;
}
void assign_pos(pos cur, maze **M)//标记
{
    (*M)->mz[cur.row][cur.col] = 2;
}
int check_exit(pos cur, maze *M)//检查是否到达出口
{
    if ((cur.row == 0) || (cur.row == N - 1) || (cur.col == 0) || (cur.col == N - 1))
    {
        if ((cur.row) != ((M->entry).row) && (cur.col) != ((M->entry).col))
        {
            return 1;
        }

    }
    return 0;
}

void print_stack(Stack *s)
{
    printf("找到出口！\n\n");
    printf("栈顶\n");
    for (size_t i = 0;i < s->_top;i++)
    {
        printf("[%d %d]\n", s->_array[i].row, s->_array[i].col);
    }
    printf("栈底\n\n");
    printf("路径长度为%u\n", s->_top);
}
void simple_getpath(maze *M, pos cur, Stack *s)
{

    assert(M);
    //2.判定当前点坐标是否可以走。（坐标合法且不为0）

    if (can_stay(cur, M) == 1)
    {
        //3.如果合法则将当前点标记成走过的并入栈
        //（维护一个栈可以记录走过的路径，栈的长度就是路径的长度）
        assign_pos(cur, &M);
        StackPush(s, cur);
    }
    else
    {
        return;
    }
    if (check_exit(cur, M) == 1)
    {
        print_stack(s);
        return;
    }
    //4.判断当前点是否是出口，是出口就return（该迷宫不存在别的出口），
    //如果不是出口，以顺时针的方向（上，右，下，左）探测临界点是否可以走（不为0且不为已经走过的点），
    //并以递归形式重复步骤2-4.

    //up
    pos up = cur;
    up.row -= 1;
    simple_getpath(M, up, s);

    //right
    pos right = cur;
    right.col += 1;
    simple_getpath(M, right, s);

    //down
    pos down = cur;
    down.row += 1;
    simple_getpath(M, down, s);

    //left
    pos left = cur;
    left.col -= 1;
    simple_getpath(M, left, s);


    //5.当一个点的4个方向都已经探测过，就返回上一层栈帧。
    StackPop(s);
    return;



}

test.c

#include"function.h"

void simplemaze()
{
    maze M;
    Stack path;
    StackInit(&path);
    mazeinit(&M);
    mazeprint(&M);
    simple_getpath(&M, M.entry, &path);
    mazeprint(&M);
}

int main()
{
    simplemaze();
    system("pause");
    return 0;
}

这里写图片描述

第二类 多通路迷宫（不带环）

这里写图片描述

思路：

这个迷宫与简单迷宫非常类似，唯一不同就是有多通路，我们要求解离开迷宫的最短距离，每当移动到出口时，我们的栈path就记录了该条路径，再与shortpath进行比较（初次遇到出口时直接令shortpath和path相等即可），让shortpath始终保留最短的通路，直到再次回到起点（所有栈帧均释放完毕）。

function.h

#include"maze.h"

void StackInit(Stack* s)//栈的初始化
{
    assert(s);
    s->_array = (DataType*)malloc(sizeof(DataType)*Stack_size);
    s->_end = Stack_size;
    s->_top = 0;

}

void StackPush(Stack* s, DataType x)//入栈
{
    assert(s);
    if (s->_end == s->_top)//栈已满
    {
        s->_end *= 2;
        s->_array = (DataType*)realloc(s->_array, sizeof(DataType)*(s->_end));
        s->_array[s->_top] = x;
        (s->_top)++;
    }
    else
    {
        s->_array[s->_top] = x;
        (s->_top)++;
    }
}


void StackPop(Stack* s)//出栈
{
    assert(s);
    if (s->_top == 0)
    {
        printf("the stack is empty");
    }
    else
    {
        s->_top--;
    }
}

int StackEmpty(Stack* s)//判断栈是否为空
{
    if (s->_top == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

DataType StackTop(Stack* s)//取栈顶元素
{
    assert(s);


    int num = s->_top;
    DataType  i = s->_array[(--num)];
    return i;

}

//1.创建迷宫(二维数组)并初始化
//2.将迷宫入口的值设为2，入栈，然后依次对上，右，下，左依次进行判断，
//如果不越界&&坐标不为0 || 当前坐标值比下一步的坐标值小，则进行递归，并入栈，递归出口为当前节点不为起点
//3.每当遇到出口，如果shortpath为空或者path比shortpath短，则将path的值依次赋给shortpath。


void mazeinit(maze *M)//迷宫初始化
{
    assert(M);
    int a[N][N] = {
        { 0, 0, 0, 0, 0, 0 },
        { 0, 1, 1, 1, 1, 1 },
        { 0, 1, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0 },
        { 0, 1, 1, 1, 1, 1 },
        { 0, 1, 0, 0, 0, 0 }
    };
    for (size_t i = 0;i < N;i++)
    {
        for (size_t j = 0;j < N;j++)
        {
            M->mz[i][j] = a[i][j];
        }
    }
    M->entry.row = 5;
    M->entry.col = 1;
}

void mazeprint(maze *M)
{
    assert(M);
    for (int i = 0;i < N;i++)
    {
        for (int j = 0;j < N;j++)
        {
            printf("%d  ", (M->mz)[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
int can_stay(pos cur, maze *M)//判断是否能入栈
{
    if (cur.row >= 0 && cur.row < N&&cur.col >= 0 && cur.col < N //坐标合法
        &&M->mz[cur.row][cur.col] != 0 && M->mz[cur.row][cur.col] != 2)   //该点不为墙也不为走过的点
    {
        return 1;
    }
    return 0;
}
void assign_pos(pos cur, maze **M)//标记
{
    (*M)->mz[cur.row][cur.col] = 2;
}
int check_exit(pos cur, maze *M)//检查是否到达出口
{
    if ((cur.row == 0) || (cur.row == N - 1) || (cur.col == 0) || (cur.col == N - 1))
    {
        if ((cur.row) != ((M->entry).row) && (cur.col) != ((M->entry).col))
        {
            return 1;
        }

    }
    return 0;
}

void print_stack(Stack *s)
{
    printf("找到出口！\n\n");
    printf("栈顶\n");
    for (size_t i = 0;i < s->_top;i++)
    {
        printf("[%d %d]\n", s->_array[i].row, s->_array[i].col);
    }
    printf("栈底\n\n");
    printf("路径长度为%u\n", s->_top);
}
void get_shortpath(maze *M, pos cur, Stack *path,Stack *shortpath)
{

    assert(M);
    //2.判定当前点坐标是否可以走。（坐标合法且不为0）

    if (can_stay(cur, M) == 1)
    {
        //3.如果合法则将当前点标记成走过的并入栈
        //（维护一个栈可以记录走过的路径，栈的长度就是路径的长度）
        assign_pos(cur, &M);
        StackPush(path, cur);
    }
    else
    {
        return;
    }

    if (check_exit(cur, M) == 1)
    {
        if ((shortpath->_top == 0) || (shortpath->_top > path->_top))
        {
            shortpath->_top = path->_top;
            memcpy(shortpath, path, sizeof(path));
            print_stack(path);
            StackPop(path);
            return;
        }
    }
    //4.判断当前点是否是出口，是出口就return（该迷宫不存在别的出口），
    //如果不是出口，以顺时针的方向（上，右，下，左）探测临界点是否可以走（不为0且不为已经走过的点），
    //并以递归形式重复步骤2-4.

    //up
    pos up = cur;
    up.row -= 1;
    get_shortpath(M, up, path,shortpath);

    //right
    pos right = cur;
    right.col += 1;
    get_shortpath(M, right, path, shortpath);

    //down
    pos down = cur;
    down.row += 1;
    get_shortpath(M, down, path, shortpath);

    //left
    pos left = cur;
    left.col -= 1;
    get_shortpath(M, left, path, shortpath);


    //5.当一个点的4个方向都已经探测过，就返回上一层栈帧。
    StackPop(path);
    return;



}

maze.h

#pragma once
#include<stdio.h>
#include<windows.h>
#include<assert.h>
//要定义的有：
//一个结构体为结构体pos，用于记录迷宫每个店的横纵坐标
//两个栈path和shortpath，记录通路的最短距离,栈内元素序列即是最短
//迷宫（迷宫地图，入口点）
#define N 6
#define Stack_size 20
typedef struct pos            //迷宫内每个点的坐标
{
    int row;
    int col;
}pos;

typedef pos DataType;

typedef struct Stack         //存放节点信息的栈
{
    DataType* _array;        //数组指针
    size_t  _top;            //栈顶 
    size_t  _end;            //最大容量
}Stack;

typedef struct maze          //迷宫
{
    int mz[N][N];
    pos entry;               //入口点
}maze;

test.c

#include"function.h"

void simplemaze()
{
    maze M;
    Stack path;
    Stack shortpath;
    StackInit(&path);
    StackInit(&shortpath);
    mazeinit(&M);
    mazeprint(&M);
    get_shortpath(&M, M.entry, &path,&shortpath);
    mazeprint(&M);
}

int main()
{
    simplemaze();
    system("pause");
    return 0;
}

这里写图片描述

第三类 带环迷宫

带环迷宫是这三种迷宫中最难的一种，也是最容易弄错的一种，如果是用上面两种把走过的路标记为2的方法做带环问题，有一些通路可能会被忽略。所以这里用的方法是：将入口点标记成2，之后每移动一步就将下一个点的值设为X+1（x是上一个点的值，每个点的值表示从起点算X-1步可以到达。

而判断是否可以入栈的规则也有变化（（坐标合法&&不为0）|| 该点值 - 1 > 上一个点的坐标）.

这里肯定有人会为什么规则是这样的，打个比方：

点A的值为10（从起点通过9步到达），他的相邻点B的值是11（从起点通过10步到达），这时候就不用走，因为已经有另一条路通过相同的步数到达B。

点A的值是10，相邻点B的值是10，这时候就一定不能走，因为如果走，B的值就得改成11，比原先的步数还要多，这一定不是最短的路程。

点A的值是10，相邻点B的值是12，这时候就可以走，因为通过A到B可以比原先另一种方式节省一步。

function.h

#include"maze.h"

void StackInit(Stack* s)//栈的初始化
{
    assert(s);
    s->_array = (DataType*)malloc(sizeof(DataType)*Stack_size);
    s->_end = Stack_size;
    s->_top = 0;

}

void StackPush(Stack* s, DataType x)//入栈
{
    assert(s);
    if (s->_end == s->_top)//栈已满
    {
        s->_end *= 2;
        s->_array = (DataType*)realloc(s->_array, sizeof(DataType)*(s->_end));
        s->_array[s->_top] = x;
        (s->_top)++;
    }
    else
    {
        s->_array[s->_top] = x;
        (s->_top)++;
    }
}


void StackPop(Stack* s)//出栈
{
    assert(s);
    if (s->_top == 0)
    {
        printf("the stack is empty");
    }
    else
    {
        s->_top--;
    }
}

int StackEmpty(Stack* s)//判断栈是否为空
{
    if (s->_top == 0)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

DataType StackTop(Stack* s)//取栈顶元素
{
    assert(s);


    int num = s->_top;
    DataType  i = s->_array[(--num)];
    return i;

}

//1.创建迷宫(二维数组)并初始化
//2.将迷宫入口的值设为2，入栈，然后依次对上，右，下，左依次进行判断，
//如果不越界&&坐标不为0 || 当前坐标值比下一步的坐标值小，则进行递归，并入栈，递归出口为当前节点不为起点
//3.每当遇到出口，如果shortpath为空或者path比shortpath短，则将path的值依次赋给shortpath。


void mazeinit(maze *M)//迷宫初始化
{
    assert(M);
    int a[N][N] = {
        { 0,0,0,0,0,0 },
        { 0,1,1,1,0,0 },
        { 0,1,0,1,0,0 },
        { 0,1,0,1,0,0 },
        { 0,1,1,1,1,1 },
        { 0,1,0,0,0,0 },
    };
    for (size_t i = 0;i < N;i++)
    {
        for (size_t j = 0;j < N;j++)
        {
            M->mz[i][j] = a[i][j];
        }
    }
    M->entry.row = 5;
    M->entry.col = 1;
}

void mazeprint(maze *M)
{
    assert(M);
    for (int i = 0;i < N;i++)
    {
        for (int j = 0;j < N;j++)
        {
            printf("%d  ", (M->mz)[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
int can_stay(pos cur, maze *M,int value)//判断是否能入栈
{

    if (cur.row >= 0 && cur.row < N&&cur.col >= 0 && cur.col < N) //坐标合法
    {
        if (M->mz[cur.row][cur.col] == 1 || M->mz[cur.row][cur.col] - 1>value )
        {
            return 1;
        }                                                       //该点不为墙且大于前一个点的值+1
    }                     
    return 0;
}
void assign_pos(pos cur, maze **M,int value)//标记
{
    (*M)->mz[cur.row][cur.col] = value;
}
int check_exit(pos cur, maze *M)//检查是否到达出口
{
    if ((cur.row == 0) || (cur.row == N - 1) || (cur.col == 0) || (cur.col == N - 1))
    {
        if ((cur.row) != ((M->entry).row) && (cur.col) != ((M->entry).col))
        {
            return 1;
        }

    }
    return 0;
}

void print_stack(Stack *s)
{
    printf("找到出口！\n\n");
    printf("栈顶\n");
    for (size_t i = 0;i < s->_top;i++)
    {
        printf("[%d %d]\n", s->_array[i].row, s->_array[i].col);
    }
    printf("栈底\n\n");
    printf("路径长度为%u\n", s->_top);
}
void get_shortpath(maze *M, pos cur, Stack *path,Stack *shortpath,int value)
{

    assert(M);
    //2.判定当前点坐标是否可以走。（坐标合法且不为0）

    if (can_stay(cur, M,value) == 1)
    {
        //3.如果合法则将当前点标记成走过的并入栈
        //（维护一个栈可以记录走过的路径，栈的长度就是路径的长度）
        assign_pos(cur, &M,value);
        value += 1;
        StackPush(path, cur);
    }
    else
    {
        return;
    }

    if (check_exit(cur, M) == 1)
    {
        if ((shortpath->_top == 0) || (shortpath->_top > path->_top))
        {
            shortpath->_top = path->_top;
            memcpy(shortpath, path, sizeof(path));
            print_stack(path);
            StackPop(path);
            return;
        }
    }
    //4.判断当前点是否是出口，是出口就return（该迷宫不存在别的出口），
    //如果不是出口，以顺时针的方向（上，右，下，左）探测临界点是否可以走（不为0且不为已经走过的点），
    //并以递归形式重复步骤2-4.

    //up
    pos up = cur;
    up.row -= 1;
    get_shortpath(M, up, path,shortpath,value);

    //right
    pos right = cur;
    right.col += 1;
    get_shortpath(M, right, path, shortpath,value);

    //down
    pos down = cur;
    down.row += 1;
    get_shortpath(M, down, path, shortpath,value);

    //left
    pos left = cur;
    left.col -= 1;
    get_shortpath(M, left, path, shortpath,value);


    //5.当一个点的4个方向都已经探测过，就返回上一层栈帧。
    StackPop(path);
    return;



}

maze.h

#pragma once
#include<stdio.h>
#include<windows.h>
#include<assert.h>
//要定义的有：
//一个结构体为结构体pos，用于记录迷宫每个店的横纵坐标
//两个栈path和shortpath，记录通路的最短距离,栈内元素序列即是最短
//迷宫（迷宫地图，入口点）
#define N 6
#define Stack_size 20
typedef struct pos            //迷宫内每个点的坐标
{
    int row;
    int col;
}pos;

typedef pos DataType;

typedef struct Stack         //存放节点信息的栈
{
    DataType* _array;        //数组指针
    size_t  _top;            //栈顶 
    size_t  _end;            //最大容量
}Stack;

typedef struct maze          //迷宫
{
    int mz[N][N];
    pos entry;               //入口点
}maze;

test.c

#include"function.h"

void simplemaze()
{
    maze M;
    Stack path;
    Stack shortpath;
    StackInit(&path);
    StackInit(&shortpath);
    mazeinit(&M);
    mazeprint(&M);
    get_shortpath(&M, M.entry, &path,&shortpath,2);
    mazeprint(&M);
}

int main()
{
    simplemaze();
    system("pause");
    return 0;
}

这里写图片描述

猜你喜欢

转载自blog.csdn.net/ferlan/article/details/79781106
今日推荐
周排行
LRU cache算法
windows10, 自带的OpenSSH, key权限问题, 文件权限问题
测试用例书写方法
HIVE-默认分隔符的（linux系统的特殊字符）查看，输入和修改
最贵的AMD 7nm显卡来了！这设计 够狂野
java多线程简单demo
[ 转载 ]在Android系统上使用busybox——最简单的方法
QT connect学习
BFSIFT算法分析
Xcode10：library not found for -lstdc++.6.0.9 临时解决
每日归档
更多
2024-08-06(0)
2024-08-05(0)
2024-08-04(0)
2024-08-03(0)
2024-08-02(0)
2024-08-01(0)
2024-07-31(0)
2024-07-30(0)
2024-07-29(0)
2024-07-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022