多通路迷宫最短路径(寻路加找宝箱)

已于 2022-08-08 11:38:32 修改
阅读量1.9k 收藏 57
点赞数 9
分类专栏： 迷宫生成与寻路算法 文章标签： pygame python 开发语言
于 2021-05-06 17:50:54 首次发布
除特殊说明外，原创文章禁止转载。原创文章已同步到 https://www.alom.com.cn/。
本文链接：https://blog.csdn.net/defaultbyzt/article/details/116456232
版权

多通路迷宫最短路径找宝箱版

图示

在这里插入图片描述

寻路需求

这次我们在一个多路径迷宫中放置几个宝箱 ，从起点出发找到所有的宝箱之后再寻路到终点。

演示代码

#!/usr/bin/python3.7
# -*- coding: utf-8 -*-
import random
import pygame
import maze
# 
pygame.init()  # 初始化pygame
size = width, height = 800, 600  # 设置窗口大小
screen = pygame.display.set_mode(size)  # 显示窗口
# 颜色
diamond_color_size = 12
COLOR_RED, COLOR_BLUE, COLOR_GREEN, COLOR_YELLOW, COLOR_BLACK, COLOR_FLAXEN, COLOR_GOLD, COLOR_GRAY, COLOR_PINK, COLOR_ORANGE, COLOR_WHEAT, COLOR_CYAN = list(range(
    diamond_color_size))
COLOR = {
    COLOR_RED: (255, 0, 0), # 红
    COLOR_BLUE: (0, 0, 255), # 蓝
    COLOR_GREEN: (0, 255, 0), # 绿
    COLOR_YELLOW: (255, 255, 0), # 黄
    COLOR_BLACK: (0, 0, 0), # 黑
    COLOR_FLAXEN: (250, 240, 230), # 亚麻
    COLOR_GOLD : (255,215,0), # 金
    COLOR_GRAY: (128,128,128), # 灰
    COLOR_PINK:(255,192,203), # 粉
    COLOR_ORANGE: (255,165,0),# 橙
    COLOR_WHEAT: (245,222,179),# 小麦
    COLOR_CYAN : (0,255,255), # 青
}
# 格子大小
DIAMOND_LEN = 20
DIAMOND_SIZE = (DIAMOND_LEN, DIAMOND_LEN)
# 各色的格子
DIAMONDS=[]
for x in range(diamond_color_size):
    diamoand=pygame.surface.Surface(DIAMOND_SIZE).convert()
    diamoand.fill(COLOR[x])
    DIAMONDS.append(diamoand)

DIAMONDS=[]
for x in range(diamond_color_size):
    diamoand=pygame.surface.Surface(DIAMOND_SIZE).convert()
    diamoand.fill(COLOR[x])
    DIAMONDS.append(diamoand)


# 字体
use_font = pygame.font.Font("FONT.TTF", 16)
use_font12 = pygame.font.Font("FONT.TTF", 12)
# 背景
background=pygame.surface.Surface(size).convert()
background.fill(COLOR[COLOR_BLACK])
# 文字
score_surface = use_font.render("找到终点", True, COLOR[COLOR_BLACK], COLOR[COLOR_FLAXEN])
# 时间
clock = pygame.time.Clock()
#标记 
NOWALL=maze.NOWALL # 无墙
WALL=maze.WALL  # 有墙
WALL2=maze.WALL2  # 有墙
VISIT=maze.VISIT # 到访过
NOVISIT=maze.NOVISIT # 没到过
VERTICAL = maze.VERTICAL # 垂直的
HORIZONTAL = maze.HORIZONTAL# 水平的
INFINITE = maze.INFINITE # 无穷远

def DrawCircle(screen,  position, color, pure=False, radius=6, width=6):
    if pure:
        pygame.draw.circle(screen, color, position, radius, width)
    else:
        pygame.draw.circle(screen, color, position, radius-3, 3)
        pygame.draw.circle(screen, COLOR[COLOR_RED], position, radius-2, 1)
        pygame.draw.circle(screen, COLOR[COLOR_GREEN], position, radius-1, 1)
        pygame.draw.circle(screen, COLOR[COLOR_BLUE], position, radius, 1)
    #pygame.draw.circle(screen, color, position, radius, 1)
    #pygame.draw.circle(screen, color, position, radius, 1)
    #pygame.draw.circle(screen, color, position, radius, 1)

# 下一圈
def FindNextCircle(startList, walls, grids, rows, cols):
    startNextList = [] # 下一步
    for node in startList:
        r, c = node
        l = grids[r][c]
        # 可以到达的位置
        if r>0 and NOWALL == walls[r][c][1] and INFINITE == grids[r-1][c]:
            # move = 'u'
            nr=r-1
            nc=c
            if (nr,nc) not in startNextList:
                startNextList.append((nr,nc))
                grids[nr][nc] = l+1
        if c>0 and NOWALL == walls[r][c][0] and INFINITE == grids[r][c-1]:
            # move = 'l'
            nr=r
            nc=c-1
            if (nr,nc) not in startNextList:
                startNextList.append((nr,nc))
                grids[nr][nc] = l+1
        if c<cols-1 and NOWALL == walls[r][c+1][0] and INFINITE == grids[r][c+1] :
            # move='r'
            nr=r
            nc=c+1
            if (nr,nc) not in startNextList:
                startNextList.append((nr,nc))
                grids[nr][nc] = l+1
        if r<rows-1 and NOWALL == walls[r+1][c][1] and INFINITE == grids[r+1][c] :
            # move='d'
            nr=r+1
            nc=c
            if (nr,nc) not in startNextList:
                startNextList.append((nr,nc))
                grids[nr][nc] = l+1
    # 下一圈
    startList.clear()
    startList.extend(startNextList)
    return startList

def sample_findmainpath_step(r, c, mainList, walls, grids, rows, cols):
    # 演示生成最短路径过程
    findMainPath = False
    mainList.append((r,c))
    l = grids[r][c]
    nl=l-1
    # 最近的
    if r>0 and NOWALL == walls[r][c][1] and nl == grids[r-1][c]:
        # move = 'u'
        nr=r-1
        nc=c
    elif c>0 and NOWALL == walls[r][c][0] and nl == grids[r][c-1]:
        # move = 'l'
        nr=r
        nc=c-1
    elif c<cols-1 and NOWALL == walls[r][c+1][0] and nl == grids[r][c+1] :
        # move='r'
        nr=r
        nc=c+1
    elif r<rows-1 and NOWALL == walls[r+1][c][1] and nl == grids[r+1][c] :
        # move='d'
        nr=r+1
        nc=c
    # 找到起点
    if 0 == nl:
        mainList.append((nr,nc))
        findMainPath = True
    r,c=nr,nc
    return r,c, findMainPath

def sample_findpathing_step(startList, walls, grids, rows, cols, treasures):
    # 演示寻路过程
    # 初始化未访问
    findPath = False
    startNextList = [] # 下一步
    for node in startList:
        r, c = node
        l = grids[r][c]
        ln=l+1
        if node in treasures:
            findPath = True
            startList.clear()
            break
        # 可以到达的位置
        if r>0 and NOWALL == walls[r][c][1] and INFINITE == grids[r-1][c]:
            # move = 'u'
            nr=r-1
            nc=c
            if (nr,nc) not in startNextList:
                startNextList.append((nr,nc))
                grids[nr][nc] = ln
        if c>0 and NOWALL == walls[r][c][0] and INFINITE == grids[r][c-1]:
            # move = 'l'
            nr=r
            nc=c-1
            if (nr,nc) not in startNextList:
                startNextList.append((nr,nc))
                grids[nr][nc] = ln
        if c<cols-1 and NOWALL == walls[r][c+1][0] and INFINITE == grids[r][c+1] :
            # move='r'
            nr=r
            nc=c+1
            if (nr,nc) not in startNextList:
                startNextList.append((nr,nc))
                grids[nr][nc] = ln
        if r<rows-1 and NOWALL == walls[r+1][c][1] and INFINITE == grids[r+1][c] :
            # move='d'
            nr=r+1
            nc=c
            if (nr,nc) not in startNextList:
                startNextList.append((nr,nc))
                grids[nr][nc] = ln
    # 下一圈
    startList.clear()
    startList.extend(startNextList)
    return findPath, r, c

# 画方块
def draw_diamond(r, c, screen, diamod):
    px,py= 1 + (c) * DIAMOND_SIZE[0], 1 + (r) * DIAMOND_SIZE[1]
    screen.blit(diamod, (px, py))
    return 


# 画方块和字符串string
def draw_diamond_and_str(r, c, screen, diamod, use_font, string, color, color_back):
    px,py= 1 + (c) * DIAMOND_SIZE[0], 1 + (r) * DIAMOND_SIZE[1]
    screen.blit(diamod, (px, py))
    distance_surface = use_font.render(string, True, color, color_back)
    screen.blit(distance_surface, (px, py))
    return 


# Sample algorithm
def multipath_maze_demo(rows, cols):
    maze_h = rows * DIAMOND_SIZE[0] + 1
    maze_w = cols * DIAMOND_SIZE[0] + 1
    size = (maze_w, maze_h)
    # 迷宫图层
    maze_surface=pygame.surface.Surface(size).convert()
    #walls = maze.aldous_broder_maze(rows, cols)
    #walls = maze.depth_maze(rows, cols)
    #walls = maze.kruskal_maze(rows, cols)
    #walls = maze.prim_maze(rows, cols)
    #walls = maze.wilson_maze(rows, cols)
    walls = maze.wilson_maze(rows, cols)
    # 画
    posion_xy=(40, 40)
    # 初始化未访问
    grids=[[ INFINITE for i in range(cols)]for j in range(rows)]
    # 起点
    # 标记迷宫
    r=0
    c=0
    startPoint=(r,c)  # 起点
    endPoint=(rows-1,cols-1)  # 终点
    # 拆出多条路
    maze.down_wall_maze(walls, rows, cols, startPoint, endPoint)
    maze.down_wall_maze(walls, rows, cols, startPoint, endPoint)
    # 随机N个宝箱
    n=3
    treasures=[]   
    tmpTreasures=[] 
    while n > 0:
        r = random.randint(0, rows-1)
        c = random.randint(0, cols-1)
        if (r,c) not in treasures and (r,c) != startPoint and (r,c) != endPoint:
            treasures.append((r,c))
            tmpTreasures.append((r,c))
            n -=1
    # 
    mainList=[] # 主路径
    # 标记
    findEndPoint=False
    findPath=False
    findTreasures=None
    findMainPath=None
    # 
    startList=[startPoint]
    grids[startPoint[0]][startPoint[1]]=0 # 标记已经到过格子距离   
    startMap=[]
    startMap += startList
    # 
    parts = []
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                return
        if not findPath:
            # 寻路过程
            if tmpTreasures:  # 找宝箱
                findPath, r, c = sample_findpathing_step(startList, walls, grids, rows, cols, tmpTreasures)
                # treasures.remove((r, c))
                treasurePoint=(r,c)
            else:  # 找终点
                findPath, r, c = sample_findpathing_step(startList, walls, grids, rows, cols, [endPoint])
        elif not findMainPath:
            # 回溯路径
            r, c, findMainPath = sample_findmainpath_step(r, c, mainList, walls, grids, rows, cols)
            # 
            if findMainPath:
                # 宝箱已经找全部找到
                if not tmpTreasures:
                    findEndPoint = True
        else:
            if not findEndPoint:
                grids=[[ INFINITE for i in range(cols)]for j in range(rows)]
                startMap=[]
                if tmpTreasures:
                    tmpTreasures.remove(treasurePoint)
                    findPath = False
                    findMainPath = False
                    startList=[treasurePoint]
                    grids[treasurePoint[0]][treasurePoint[1]]=0 # 标记已经到过格子距离   
                    startMap += startList
        # 背景
        screen.blit(background, (0, 0))
        # maze_surface
        # 格子
        for cx in range(cols):
            for ry in range(rows):
                # 标记访问过的格子
                if maze.INFINITE == grids[ry][cx]:
                    draw_diamond(ry, cx, maze_surface, DIAMONDS[COLOR_GRAY])
                else:
                    s = "{}".format(grids[ry][cx])
                    draw_diamond_and_str(ry, cx, maze_surface, DIAMONDS[COLOR_WHEAT], use_font12, s, COLOR[COLOR_BLACK], COLOR[COLOR_WHEAT]) 
        # 圈地
        for pos in startMap:
            s = "{}".format(grids[pos[0]][pos[1]])
            draw_diamond_and_str(pos[0], pos[1], maze_surface, DIAMONDS[COLOR_WHEAT], use_font12, s, COLOR[COLOR_BLACK], COLOR[COLOR_WHEAT])
        # 循环外圈
        if startList and not mainList:
            for pos in startList:
                s = "{}".format(grids[pos[0]][pos[1]])
                draw_diamond_and_str(pos[0], pos[1], maze_surface, DIAMONDS[COLOR_RED], use_font12, s, COLOR[COLOR_BLACK], COLOR[COLOR_RED])
        # 路径
        if mainList:
            for pos in mainList:
                s = "{}".format(grids[pos[0]][pos[1]])
                draw_diamond_and_str(pos[0], pos[1], maze_surface, DIAMONDS[COLOR_YELLOW], use_font12, s, COLOR[COLOR_BLACK], COLOR[COLOR_YELLOW])
            # r,c
            s = "{}".format(grids[pos[0]][pos[1]])
            draw_diamond_and_str(r, c, maze_surface, DIAMONDS[COLOR_GREEN], use_font12, s, COLOR[COLOR_BLACK], COLOR[COLOR_GREEN])
        # 画外墙
        pygame.draw.rect(maze_surface, COLOR[COLOR_RED], (0, 0, DIAMOND_LEN*cols+1, DIAMOND_LEN*rows+1), 2)
        # 画没打通的墙
        DrawWalls(maze_surface, DIAMOND_SIZE, walls, rows, cols)
        # 
        if parts:
            DrawWallList(maze_surface, COLOR[COLOR_RED], DIAMOND_SIZE, parts, rows, cols)
        # 
        if startPoint:
            pos = (startPoint[1]*DIAMOND_LEN + 10, startPoint[0]*DIAMOND_LEN + 10)
            DrawCircle(maze_surface, pos, COLOR[COLOR_RED])
        if endPoint:
            pos = (endPoint[1]*DIAMOND_LEN + 10, endPoint[0]*DIAMOND_LEN + 10)
            DrawCircle(maze_surface, pos, COLOR[COLOR_RED])
        # 
        if treasures:
            for p in treasures:
                pos = (p[1]*DIAMOND_LEN + 10, p[0]*DIAMOND_LEN + 10)
                DrawCircle(maze_surface, pos, COLOR[COLOR_GOLD])

        # 贴maze
        screen.blit(maze_surface, posion_xy)

        # 打印文字提示
        if findEndPoint:
            screen.blit(score_surface, (100, 20+rows*22))
        # 帧率
        clock.tick(25)

        pygame.display.update()
    return 

# 
def DrawWalls(screen, DIAMOND_SIZE, walls, rows, cols):
    for cx in range( cols):
        for ry in range(rows):
            px,py = 1 + (cx) * DIAMOND_SIZE[0], 1 + (ry) * DIAMOND_SIZE[1]
            color = COLOR[COLOR_BLACK]
            if maze.WALL == walls[ry][cx][0]:
                pygame.draw.line(screen, color, (px, py), (px, py+DIAMOND_LEN), 2)
            if maze.WALL == walls[ry][cx][1]:
                pygame.draw.line(screen, color, (px, py), (px+DIAMOND_LEN, py), 2)
    return 

# 
def DrawWallList(screen, color, DIAMOND_SIZE, wlist, rows, cols):
    for r,c,d in wlist:
        px,py = 1 + (c) * DIAMOND_SIZE[0], 1 + (r) * DIAMOND_SIZE[1]
        if d == 0:
            pygame.draw.line(screen, color, (px, py), (px, py+DIAMOND_LEN), 2)
        if d == 1:
            pygame.draw.line(screen, color, (px, py), (px+DIAMOND_LEN, py), 2)
    return 


# main
if __name__ == "__main__":
    '''main'''
    multipath_maze_demo(20, 30)

演示

在这里插入图片描述

火苗999℃
关注
  • 9
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
数据结构---复杂迷宫求解（多路径带环）
y6_xiamo的博客
04-27 762
上一篇博客我们提到了多出口迷宫的情况，但是在此基础上迷宫路径如果带环呢，如何解决？ 情况如下图： 可以看出，红色圈出来的部分形成了一个环。那如果我们还是采用上次的办法，看看能不能找出最短路径。 通过上图，我们可以看到并不能达到预期效果，打印出来的并不是最短路径。这是为什么呢？ 原因在于我们按照顺时针“上右下左”的顺序探测该点四周能否能落脚时，如下面 A 图所示，先找到了第一条路径即...
迷宫最短路径算法（dfs）
02-26
而迷宫最短路径问题就是找出从迷宫入口到出口所经过单元格个数最少的路径。 深度优先搜索（DFS）是一种经典算法，用于解决迷宫问题。该算法的思想是从入口出发，顺着某一方向向前探索，若能走通，则继续往前走；...
迷宫最短路径算法(Sample algorithm)
火苗999℃的博客
04-26 964
Sample algorithm算法介绍英文介绍我的翻译寻路结果图演示代码GIF动画演示参考 算法介绍 英文介绍 This is a fairly simple and easy-to-understand pathfinding algorithm for tile-based maps. To start off, you have a map, a start coordinate and a destination coordinate. The map will look like this,
AI创想家，迷宫寻宝
最新发布
qq_35738121的博客
06-19 1808
print(f'最有价值物品: [Value = {bestValue:.2f}][Item = {bestItem}]')print(f'第{round}回合, 待收集的宝石: {ret}')# 计算物品附近的宝石, 优先前往资源丰富的区域。# 如果敌人正在远离宝石。# 否则敌人正在靠近宝石。# 如果敌人正在远离宝石。# 否则敌人正在靠近宝石。else: # 如果敌人离宝石更远。# 得到成套宝石中, 还缺少的宝石名称。# 如果敌人离宝石更近。# 获取玩家的宝石收集情况。# 如果是待收集的宝石。
(FZU-2285-迷宫寻宝)BFS最短路径问题
0xcc'Blog
03-09 1100
题目网址:http://acm.fzu.edu.cn/problem.php?pid=2285 Problem 2285 迷宫寻宝 Accept: 276 Submit: 1040 Time Limit: 1000 mSec Memory Limit : 32768 KB Problem Description 洪尼玛今天准备去寻宝，在一个n*n （n行, n列）的迷宫中，存在着一...
多通路带环和不带环迷宫求最短路径（C语言）
小心眼儿猫的博客
04-21 497
求解了简单迷宫，接下来我们来看一看多通路的带环和不带环的迷宫求最短路径的问题。 问题一：不带环的多通路迷宫求最短路径 思路： 1、给定一个点，判断该点是否能落脚，不能落脚直接返回 2、能落脚就将这个点标记，并且入栈cur_path，该栈中保存着我们走过的路径 3、判断这个点是否为出口，是出口说明找到了一条路 4、此时cur_path栈中保存着我们走过的这条路，将cur...
C++编程练习--DFS深搜寻找迷宫最短路径
有朋自远方来，不亦乐乎。
12-01 893
（左：迷宫 右： 最短路径） 代码： #include<iostream> #include<string.h> #include<stdio.h> #define N 1001 using namespace std; struct St { int x; int y; }s[N],sMin[N];//记录路径坐标的栈 int Map[25][25] = { //迷宫地图 {1,1,1,1,1,1,1,1,1,1,1,1,1,.....
【数据结构】------多通路带环迷宫求最短路径（C语言）
daboluo521的博客
04-28 657
思路：在解决之前的函数时，我们判断函数是否可以落脚，标记可落脚的函数都是通用的，而现在由于迷宫的通路是带环的，如果我们在使用上面提到的不带环的多通路求最短路径的方法，肯定这种结果是错误的，所以对于带环的迷宫求解我们再也不能像以前简单的标记为2，我们应该标记的是走过的步数，这样我们判断是否能落脚时，可以直接判断下一步的步数是否比我们即将标记的步数大，如果大的话，就继续进行落脚标记，否则就不可以。 ...
迷宫最短路径问题
11-22
根据给定的信息，本文将详细解释迷宫最短路径问题，并深入探讨其实现方式与算法原理。 ### 迷宫最短路径问题概述 在计算机科学领域，迷宫最短路径问题是一个经典的数据结构实验课题。它涉及到寻找一个二维网格迷宫...
c语言支持自己创建迷宫，并求解最短路径.rar
08-10
在C语言中创建一个自定义迷宫并求解最短路径是一个典型的算法问题，涉及到数据结构和算法的应用。这个问题可以通过几种方法解决，其中最常见的可能是深度优先搜索（DFS）和广度优先搜索（BFS）。这两种算法都可以...
C语言设计迷宫，找到所有路径及最短路径
09-27
printf("%s\n","**********最短路径**********\n"); for(i=1;i<=s2->top;i++) { printf("(%d,%d,%d) ->",s2->ht[i].b1,s2->ht[i].b2,s2->ht[i].id); fprintf(fp,"%c%d%c%d%c%d%c%c",'(',s2->ht[i].b1,',',s2-...
迷宫 最短路径及所有路径的问题
12-06
【迷宫最短路径及所有路径...总之，这个程序提供了一个基础的迷宫求解框架，通过栈实现了从起点到终点的所有路径的搜索，并能找出其中的最短路径。对于初学者来说，这是一个很好的学习迷宫问题解决策略和栈操作的例子。
多路径迷宫生成
火苗999℃的博客
04-28 1139
多通路迷宫生成思路介绍图示分区域演示代码 思路介绍 在已有的单路径迷宫基础上打开一块合适的墙就可以构成2路径的迷宫。 打开的墙不能和已有的路径过近。 1。从开始和终点开始进行广度优先搜索，并为迷宫中的每个单元格记录单元格远离开始和终点的步数。 2。通过将距离开头较近的所有单元格放入 start 集合，并将更接近目标的所有单元格放入end集合来将迷宫分成两个部分。 3。 选择分开两个区域的任意一面墙拆开就可以形成2通路的迷宫。 如想生成最短的通路可以选择相邻格子距离差值最大的那面墙拆开
迷宫问题寻宝（c++实现，求最短路径，显示路径）
qq_46613874的博客
08-20 1924
dfs算法迷宫问题寻宝，c++
MZY寻宝
yanghui07216的博客
08-08 441
1689: MZY寻宝 时间限制: 1 Sec  内存限制: 128 MB 提交: 153  解决: 47 [提交][状态][讨论版] 题目描述 贪心的MZY去一个迷宫寻宝。已知：若MZY在位置(x, y)，他下一次只能移动到(x-1, y)、(x+1, y)、(x, y-1)、(x, y+1)四个位置中的任一个(前提不能越界)。 毕竟他不是我，我可以直接飞到宝物那里去。由于MZY
【数据结构】利用栈解决多通路带环迷宫问题
某薛的黑猫
10-09 294
头文件 #ifndef __MAZE_H__ #define __MAZE_H__ #include &amp;amp;quot;Stack.h&amp;amp;quot; #define MAX_ROW 6 #define MAX_COL 6 typedef struct Maze { int map[MAX_ROW][MAX_COL]; }Maze; void InitMaze(Maze* m); void .
挑战程序设计——迷宫的最短路径
Recursions的博客
01-22 845
给定一个大小为 N \times MN×M 的迷宫，由通道和墙壁组成。 每一步可以向相邻的上下左右四个方向移动。 请求出起点到终点的最小步数。本题保证从起点一定能走到终点。 # 表示墙壁，不可走。 . 表示通道，可走。S 表示起点。G 表示终点。 输入 第一行两个整数N, M(1 \leq N,M \leq 100)N,M(1≤N,M≤100) 接下来NN行，每行MM个字符，表示迷宫 输出 输出一行，表示从起点到终点的最少步数 样例 1 输入 10 10 #S######.# ...
最短路题组题解
weixin_63638351的博客
02-14 567
目录 P1629 邮递员送信 P3371 【模板】单源最短路径（弱化版） P4779 【模板】单源最短路径（标准版） P1359 租用游艇 P2910 [USACO08OPEN]Clear And Present Danger S P1339 [USACO09OCT]Heat Wave G P1629 邮递员送信 思路分析： 这道题我采用的是Bellman-Ford算法，第一步求从源点1到其他点的距离直接套用模板就行。但是第二步需要回到源点1，由于题目说所有的路线都是单...
找宝藏
qq_57813305的博客
05-25 242
题目： 在一片平坦的大草原上，现在你站在一棵大树下，宝藏地图上面有一些指令，会叫你向东，西，南，北方向走若干步，最终你所站的位置就是宝藏的位置。 现在你以最短路径走向宝藏，每次仍然只能向东，西，南，北方向走动，请问至少要走几步能够到达宝藏？假设这片草原都是平坦的无障碍物的。 Input 输入一行一个指令字符串，最多200个字符。指令通过逗号分开，每一个指令由两部分组成，一个是正整数（不超过1000），以及一个方向(N (北), E (东), S (南),W (西))。比如3W表示向西走3步。字符串的
使用c语言写迷宫最短路径代码
09-16
请注意，以上代码只能找到迷宫的一条最短路径，如果存在多条最短路径，则只能找到其中的一条。如果需要找到所有最短路径，则需要使用其他更复杂的算法，如Dijkstra算法或A*算法。 ### 回答3： 要使用C语言编写迷宫...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值