迷宫求解

最新推荐文章于 2024-01-08 14:36:52 发布
最新推荐文章于 2024-01-08 14:36:52 发布
阅读量492 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 算法 迷宫 迪杰斯特拉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengsang/article/details/50321931
版权

迷宫求解

问题描述

输入： 迷宫的长、高，以及起始位置，终点位置；最大允许步数
输出：是否能通过迷宫

算法描述

该算法主要是通过迪杰斯特拉算法求解起点到终点的最小距离

代码实现

common.h

#include <stdlib.h>
#include <limits.h>

#define TRUE 1
#define FALSE 0

#define OK 0
#define ERR  1
#define MEM_ALOC_ERR 3

#define INFINITY INT_MAX

ShortestPath_Dijkstra.c 迪杰斯特拉算法[^footnote]

/*
 ============================================================================
 Name        : ShortestPath_Dijkstra.c
 Author      : Glarple
 Version     :
 Copyright   : SpecialLove
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include "common.h"

void setGraph(int **graph, int i, int j, int m, int type) {
    switch (type) {
    case 0:
        //maz[i][j] 是墙，无其他节点到该节点
        /*graph[i*m+j][(i-1)*m+j] = 0;
         graph[i*m+j][(i+1)*m+j] = 0;
         graph[i*m+j][i*m+j-1] = 0;
         graph[i*m+j][i*m+j+1] = 0;*/
        break;
    case 1:
        //maz[i][j] 上方可通行
        graph[i * m + j][(i - 1) * m + j] = 1;
        break;
    case 2:
        //maz[i][j] 下方可通行
        graph[i * m + j][(i + 1) * m + j] = 1;
        break;
    case 3:
        //maz[i][j] 上方可通行
        graph[i * m + j][(i - 1) * m + j] = 1;
        //maz[i][j] 下方可通行
        graph[i * m + j][(i + 1) * m + j] = 1;
        break;
    case 4:
        //maz[i][j] 左方可通行
        graph[i * m + j][i * m + j - 1] = 1;
        break;
    case 5:
        //maz[i][j] 上方可通行
        graph[i * m + j][(i - 1) * m + j] = 1;
        //maz[i][j] 左方可通行
        graph[i * m + j][i * m + j - 1] = 1;
        break;
    case 6:
        //maz[i][j] 下方可通行
        graph[i * m + j][(i + 1) * m + j] = 1;
        //maz[i][j] 左方可通行
        graph[i * m + j][i * m + j - 1] = 1;
        break;
    case 7:
        //maz[i][j] 上方可通行
        graph[i * m + j][(i - 1) * m + j] = 1;
        //maz[i][j] 下方可通行
        graph[i * m + j][(i + 1) * m + j] = 1;
        //maz[i][j] 左方可通行
        graph[i * m + j][i * m + j - 1] = 1;
        break;
    case 8:
        //maz[i][j] 右方可通行
        graph[i * m + j][i * m + j + 1] = 1;
        break;
    case 9:
        //maz[i][j] 上方可通行
        graph[i * m + j][(i - 1) * m + j] = 1;
        //maz[i][j] 右方可通行
        graph[i * m + j][i * m + j + 1] = 1;
        break;
    case 10:
        //maz[i][j] 下方可通行
        graph[i * m + j][(i + 1) * m + j] = 1;
        //maz[i][j] 右方可通行
        graph[i * m + j][i * m + j + 1] = 1;
        break;
    case 11:
        //maz[i][j] 上方可通行
        graph[i * m + j][(i - 1) * m + j] = 1;
        //maz[i][j] 下方可通行
        graph[i * m + j][(i + 1) * m + j] = 1;
        //maz[i][j] 右方可通行
        graph[i * m + j][i * m + j + 1] = 1;
        break;
    case 12:
        //maz[i][j] 左方可通行
        graph[i * m + j][i * m + j - 1] = 1;
        //maz[i][j] 右方可通行
        graph[i * m + j][i * m + j + 1] = 1;
        break;
    case 13:
        //maz[i][j] 上方可通行
        graph[i * m + j][(i - 1) * m + j] = 1;
        //maz[i][j] 左方可通行
        graph[i * m + j][i * m + j - 1] = 1;
        //maz[i][j] 右方可通行
        graph[i * m + j][i * m + j + 1] = 1;
        break;
    case 14:
        //maz[i][j] 下方可通行
        graph[i * m + j][(i + 1) * m + j] = 1;
        //maz[i][j] 左方可通行
        graph[i * m + j][i * m + j - 1] = 1;
        //maz[i][j] 右方可通行
        graph[i * m + j][i * m + j + 1] = 1;
        break;
    case 15:
        //maz[i][j] 上方可通行
        graph[i * m + j][(i - 1) * m + j] = 1;
        //maz[i][j] 下方可通行
        graph[i * m + j][(i + 1) * m + j] = 1;
        //maz[i][j] 左方可通行
        graph[i * m + j][i * m + j - 1] = 1;
        //maz[i][j] 右方可通行
        graph[i * m + j][i * m + j + 1] = 1;
        break;
    default:
        break;
    }
    return;
}

int getAcessType(char *maze, int i, int j, int n, int m) {
    int ret = 0;
    if (i > 0 && '*' != *(maze + (i - 1) * m + j))
        ret += 1;
    if (i < n - 1 && '*' != *(maze + (i + 1) * m + j))
        ret += 2;
    if (j > 0 && '*' != *(maze + i * m + j - 1))
        ret += 4;
    if (j < m - 1 && '*' != *(maze + i * m + j + 1))
        ret += 8;
    return ret;
}

int shortestPath_DJL(int **graph, int startPos, int princePos, int vexNum) {
    int *final;  //final[i]为true表示节点i已加入到S中，即v0到vi已找到最短路径
    int *distance;  //v0到vi的距离
    int i, j;
    int min;
    int mid = startPos;
    int ret = 0;

    final = (int *) malloc(sizeof(int) * vexNum);
    distance = (int *) malloc(sizeof(int) * vexNum);

    for (i = 0; i < vexNum; i++) {
        final[i] = FALSE;
        distance[i] = graph[startPos][i];

        /*if(distance[i] < INT_MAX)
         ;*/
    }
    /*//diag
     for (i = 0; i < vexNum; i++) {
     printf("final[%d] is %d, distance[%d] is %d\n", i, final[i], i,
     distance[i]);
     }
     ///diag*/
    final[startPos] = TRUE;
    distance[startPos] = 0;
    for (i = 0; i < vexNum; i++) {
        min = INT_MAX;
        for (j = 0; j < vexNum; j++) {
            //printf("final[%d] is %d, distance[%d] is %d.\n",j, final[j],j, distance[j]);
            if (!final[j] && distance[j] < min) {
                min = distance[j];
                mid = j;
            }
        }
        //printf("min is %d, mid is %d.\n", min, mid);
        final[mid] = TRUE;
        for (j = 0; j < vexNum; j++) {
            if (!final[j] && INT_MAX != graph[mid][j]
                    && min + graph[mid][j] < distance[j]) {
                distance[j] = min + graph[mid][j];
                /*printf("graph[%d][%d] is %d, distance[%d] is %d\n", mid, j,
                 graph[mid][j], j, distance[j]);*/
            }
        }
    }
    /*//diag
     puts("=====================");
     for (i = 0; i < vexNum; i++) {
     printf("final[%d] is %d, distance[%d] is %d\n", i, final[i], i,
     distance[i]);
     }
     ///diag*/

    ret = distance[princePos];
    free(final);
    free(distance);
    return ret;
}
/**
 * visted 描述迷宫的字符串
 * t: 表示公主能被救出的天数
 * n：迷宫的长
 * m: 迷宫的宽
 */
int SSavep(char *visited, int t, int n, int m) {
    int **graph;
    char *maze;
    int i, j;
    int nodeNum;
    int startPos, princePos;
    int accessType = 0;
    int cost = 0;
    //1、入参有效性检查
    if (visited == NULL || n < 0 || n > 20 || m < 0 || m > 20 || t < 0
            || t > 10000)
        return FALSE;
    //2、将入参的迷宫字符串，转换成图
    //  共n*m个节点，使用邻接矩阵表示
    maze = visited;
    nodeNum = n * m;
    //动态为graph申请内存
    graph = (int **) malloc(sizeof(int *) * nodeNum);
    for (i = 0; i < nodeNum; i++) {
        graph[i] = (int *) malloc(sizeof(int) * nodeNum);
    }
    //，然后将graph初始化为0，
    for (i = 0; i < nodeNum; i++) {
        for (j = 0; j < nodeNum; j++) {
            graph[i][j] = INT_MAX;  //路不通，默认置最大值 INT_MAX
        }
    }

    /*///debug
     puts("initial +++++++++++++++++++\n");
     for (i = 0; i < nodeNum; i++) {
     for (j = 0; j < nodeNum; j++) {
     if (graph[i][j] == INT_MAX)
     printf("0 ");
     else
     printf("%d ", graph[i][j]);
     }
     puts("\n");
     }
     puts("initial +++++++++++++++++++end\n");
     debug*/
    //设置graph中的值
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++) {
            //printf("maze[%d][%d] char is %c#\n", i, j, maze[i * m + j]);
            switch (maze[i * m + j]) {
            case '.':
                //判断四周情况
                accessType = getAcessType(maze, i, j, n, m);
                //设置maze[i][j] 到上下左右节点的通达信息
                setGraph(graph, i, j, m, accessType);
                break;
            case '*':
                //所有节点都不能通过这条路
                //setGraph(graph, i, j, 0);
                break;
            case 'S':
                //起点
                startPos = i * m + j;
                //判断四周情况
                accessType = getAcessType(maze, i, j, n, m);
                //设置maze[i][j] 到上下左右节点的通达信息
                setGraph(graph, i, j, m, accessType);
                break;
            case 'P':
                //终点
                princePos = i * m + j;
                //判断四周情况
                accessType = getAcessType(maze, i, j, n, m);
                //设置maze[i][j] 到上下左右节点的通达信息
                setGraph(graph, i, j, m, accessType);
                break;

            }
        }
    }
    /*///debug
     printf("startPos is %d, princessPos is %d\n", startPos, princePos);
     puts("set +++++++++++++++++++\n");
     for (i = 0; i < nodeNum; i++) {
     for (j = 0; j < nodeNum; j++) {
     if (graph[i][j] == INT_MAX)
     printf("0 ");
     else
     printf("%d ", graph[i][j]);
     }
     puts("");
     }
     puts("set +++++++++++++++++++end\n");
     debug*/
    //3、Dijkstra算法求解出最短路径
    cost = shortestPath_DJL(graph, startPos, princePos, nodeNum);

    for (i = 0; i < nodeNum; i++)
        free(graph[i]);
    free(graph);
    //4、判断最短路径和天数的大小，确认是否可以及时救出
    if (cost <= t) {
        printf("Used %d days, get out princess.\n", cost);
        return OK;
    } else {
        printf("At lease need %d days, could not get out princess.\n", cost);
        return ERR;
    }
}

int main(void) {
    puts("!!!Hello World!!!"); /* prints !!!Hello World!!! */
    char *p = "............S**P";
    SSavep(p, 6, 4, 4);
    return EXIT_SUCCESS;
}
Glarple
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
51nod 1459 迷宫游戏（迪杰特斯拉Dijkstra算法）
a617350885的专栏
08-30 1129
题目： 你来到一个迷宫前。该迷宫由若干个房间组成，每个房间都有一个得分，第一次进入这个房间，你就可以得到这个分数。还有若干双向道路连结这些房间，你沿着这些道路从一个房间走到另外一个房间需要一些时间。游戏规定了你的起点和终点房间，你首要目标是从起点尽快到达终点，在满足首要目标的前提下，使得你的得分总和尽可能大。现在问题来了，给定房间、道路、分数、起点和终点等全部信息，你能计算在尽快离开
迷宫求解MFC
06-11
本篇文章将详细探讨如何利用MFC来实现迷宫问题的求解。 迷宫问题的基本设定是一个二维网格，其中每个单元格可以是墙壁或通道。目标是从起点找到一条到达终点的可行路径。常见的解决方法包括深度优先搜索（DFS）和...
Dijkstra算法初步 - 迷宫问题
仓鼠
08-08 1234
Dijkstra算法初步 - 迷宫问题 你来到一个迷宫前。该迷宫由若干个房间组成，每个房间都有一个得分，第一次进入这个房间，你就可以得到这个分数。还有若干双向道路连结这些房间，你沿着这些道路从一个房间走到另外一个房间需要一些时间。游戏规定了你的起点和终点房间，你首要目标是从起点尽快到达终点，在满足首要目标的前提下，使得你的得分总和尽可能...
迷宫问题
qq_37941471的博客
06-22 651
题目描述 迷宫是一个二维矩阵,其中1为墙,0为路,入口在第一列,出口在最后一列。 要求从入口开始,从出口结束,按照 上,下,左,右 的顺序来搜索路径.并且求出最短路径。 思想 用回溯法，另外递归是天然的回溯法。 下面是具体的实现代码： #pragma once #include &amp;lt;iostream&amp;gt; #include &amp;lt;stack&amp;gt; usin...
DFS迷宫问题（c++）
yuyanhaonan的博客
10-24 3208
题目描述 迷宫是一个二维矩阵,其中1为墙,0为路,3为入口,4为出口.要求从入口开始,从出口结束,按照 下,左,上,右 的顺序来搜索路径. 输入 迷宫宽度w 迷宫高度h 迷宫第一行 迷宫第二行 … 迷宫第h 行 输出 入口横坐标1 入口纵坐标1 横坐标2 纵坐标2 横坐标3 纵坐标3 横坐标4 纵坐标4 … 横坐标n-1 纵坐标n-1 出口横坐标n 出口纵坐标n 样例输入 8 10 1 1 1 1 1 1 1 1 1 0 1 1 0 1 0 1 1 0 1 0 0
数据结构-迷宫（采用迪杰斯算法）最短路径走出迷宫
weixin_39518639的博客
08-18 1337
main.cpp #include <stdio.h> #include <stdlib.h> #include "function.h" void main() { int maze[ROW][COL] = { 0 }; InitMaze(maze);//初始化迷宫 DrawMaze(maze);//绘制迷宫 AImazeDijkistra(maze);//AI算法最短路径 system("pause"); } function.h #include<s
c迷宫求解
qq_36822380的博客
03-02 497
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include &lt;time.h&gt; #define n1 27//定义行范围 #define n2 27//定义列范围 typedef struct //创建一个结构体存储数组信息 { int x; int y; int c; }lu...
数据结构课程设计——迷宫求解（C语言实现）
最新发布
CharlieSuee的博客
01-08 1224
一个迷宫求解的程序（C语言实现）
migong.rar_迷宫求解
09-23
《迷宫求解：深入解析数据结构与C++编程实践》 在计算机科学领域，迷宫求解是一个经典的算法问题，它涉及到数据结构的设计和算法的实现。本篇将围绕"migong.rar_迷宫求解"的主题，探讨如何使用Visual C++来解决这一...
迷宫求解课程设计报告完整版
05-20
【迷宫求解课程设计】是计算机科学领域中常见的一个问题，通常用于教授基本的图论概念和搜索算法。在这个课程设计中，目标是设计一个C++程序，解决一个8x8的迷宫问题，从入口(1,1)找到所有可能路径及最短路径至出口...
迷宫求解问题
05-01
数据结构用C语言实现迷宫求解问题。问题的实现借助了堆栈操作。
main_迷宫_迷宫求解_源码
10-01
在IT领域，迷宫求解是一个经典的算法问题，它涉及到路径搜索、图论以及最优化策略。本项目名为"main_迷宫_迷宫求解_源码"，其核心目标是通过编程来找到给定迷宫矩阵中最短的出路。下面我们将详细探讨迷宫求解的原理...
迷宫求解的代码
09-28
在IT领域，迷宫求解是一个经典的问题，它涉及到图论、算法和数据结构等多个方面的知识。本主题的核心是设计一个程序，能够找到从迷宫的起点（入口）到终点（出口）的一条可行路径。这里我们将深入探讨迷宫求解的原理...
C++ 自定义栈实现迷宫求解
08-30
"C++ 自定义栈实现迷宫求解" C++ 自定义栈实现迷宫求解是一种常见的算法问题，通过自定义栈来实现迷宫的求解。下面我们将详细介绍该问题的知识点。 一、什么是栈？ 栈是一种数据结构，它具有先进后出的特性(FILO)...
弗洛伊德算法求出最短距离_伟大的Dijkstra算法! (算法图解第三弹)
weixin_39537680的博客
12-05 539
在介绍这个算法之前，我们一定要说提一下这个伟大的算法的发明人，Edsger Wybe Dijkstra，这个巨佬中的巨佬可是相当相当的牛逼，曾在1972年获得过素有计算机科学界的诺贝尔奖之称的图灵奖，与D. E. Knuth并称为我们这个时代最伟大的计算机科学家。听说这个巨佬中的巨佬曾经是研究数学和物理的，好奇的我去看了看他的一些研究成果?，果然，不出我所料，身为一条vegetable ...
python 迷宫求最短路径_Python使用Dijkstra算法实现求解图中最短路径距离问题详解...
weixin_39827506的博客
12-04 915
本文实例讲述了Python使用Dijkstra算法实现求解图中最短路径距离问题。分享给大家供大家参考，具体如下：这里继续前面一篇《Python基于Floyd算法求解最短路径距离问题》的内容，这里要做的是Dijkstra算法，与Floyd算法类似，二者的用途均为求解最短路径距离，在图中有着广泛的应用，二者的原理都是老生常谈了，毕竟本科学习数据结构的同学是不可能不学习这两个算法的，所以在这里我也不再累...
迷宫求解问题代码
05-21
迷宫问题是取自心理学的一个古典实验。实验中，把一只老鼠从一个没有顶的大盒子的门放入，在盒中设置了许多墙，对行进的方向形成了多处阻挡。盒子仅仅有一个出口，在出口处放置了一...请设计一个算法实现迷宫问题求解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值