第十二周项目5--迷宫问题之图深度优先遍历解法

本文介绍了一种使用深度优先搜索算法解决迷宫问题的方法。通过建立迷宫的邻接表表示,实现从入口到出口的所有可能路径寻找。文章提供了完整的C语言实现代码,并展示了运行结果。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

/*      
* Copyright (c)2016,烟台大学计算机与控制工程学院      
* All rights reserved.      
* 文件名称:项目5.cpp      
* 作    者:任家锋    
* 版 本 号:v1.0       
*问题描述:设计一个程序,采用深度优先遍历算法的思路,解决迷宫问题。  
  (1)建立迷宫对应的图数据结构,并建立其邻接表表示。  
  (2)采用深度优先遍历的思路设计算法,输出从入口(1,1)点到出口(M,N)的所有迷宫路径。  
*输入描述:无      
*程序输出:测试数据      
*/   

 

测试图如下:

<span style="font-size:12px;">#include <stdio.h>  
#include <malloc.h>  
#define MaxSize 100  
#define M 4  
#define N 4  
//以下定义邻接表类型  
typedef struct ANode            //边的结点结构类型  
{  
    int i,j;                    //该边的终点位置(i,j)  
    struct ANode *nextarc;      //指向下一条边的指针  
} ArcNode;  
  
typedef struct Vnode            //邻接表头结点的类型  
{  
    ArcNode *firstarc;          //指向第一条边  
} VNode;  
  
typedef struct  
{  
    VNode adjlist[M+2][N+2];    //邻接表头节点数组  
} ALGraph;                      //图的邻接表类型  
  
typedef struct  
{  
    int i;                      //当前方块的行号  
    int j;                      //当前方块的列号  
} Box;  
  
typedef struct  
{  
    Box data[MaxSize];  
    int length;                 //路径长度  
} PathType;                     //定义路径类型  
  
int visited[M+2][N+2]= {0};  
int count=0;  
void CreateList(ALGraph *&G,int mg[][N+2])  
//建立迷宫数组对应的邻接表G  
{  
    int i,j,i1,j1,di;  
    ArcNode *p;  
    G=(ALGraph *)malloc(sizeof(ALGraph));  
    for (i=0; i<M+2; i++)                   //给邻接表中所有头节点的指针域置初值  
        for (j=0; j<N+2; j++)  
            G->adjlist[i][j].firstarc=NULL;  
    for (i=1; i<=M; i++)                    //检查mg中每个元素  
        for (j=1; j<=N; j++)  
            if (mg[i][j]==0)  
            {  
                di=0;  
                while (di<4)  
                {  
                    switch(di)  
                    {  
                    case 0:  
                        i1=i-1;  
                        j1=j;  
                        break;  
                    case 1:  
                        i1=i;  
                        j1=j+1;  
                        break;  
                    case 2:  
                        i1=i+1;  
                        j1=j;  
                        break;  
                    case 3:  
                        i1=i, j1=j-1;  
                        break;  
                    }  
                    if (mg[i1][j1]==0)                          //(i1,j1)为可走方块  
                    {  
                        p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p  
                        p->i=i1;  
                        p->j=j1;  
                        p->nextarc=G->adjlist[i][j].firstarc;   //将*p节点链到链表后  
                        G->adjlist[i][j].firstarc=p;  
                    }  
                    di++;  
                }  
            }  
}  
//输出邻接表G  
void DispAdj(ALGraph *G)  
{  
    int i,j;  
    ArcNode *p;  
    for (i=0; i<M+2; i++)  
        for (j=0; j<N+2; j++)  
        {  
            printf("  [%d,%d]: ",i,j);  
            p=G->adjlist[i][j].firstarc;  
            while (p!=NULL)  
            {  
                printf("(%d,%d)  ",p->i,p->j);  
                p=p->nextarc;  
            }  
            printf("\n");  
        }  
}  
void FindPath(ALGraph *G,int xi,int yi,int xe,int ye,PathType path)  
{  
    ArcNode *p;  
    visited[xi][yi]=1;                   //置已访问标记  
    path.data[path.length].i=xi;  
    path.data[path.length].j=yi;  
    path.length++;  
    if (xi==xe && yi==ye)  
    {  
        printf("  迷宫路径%d: ",++count);  
        for (int k=0; k<path.length; k++)  
            printf("(%d,%d) ",path.data[k].i,path.data[k].j);  
        printf("\n");  
    }  
    p=G->adjlist[xi][yi].firstarc;  //p指向顶点v的第一条边顶点  
    while (p!=NULL)  
    {  
        if (visited[p->i][p->j]==0) //若(p->i,p->j)方块未访问,递归访问它  
            FindPath(G,p->i,p->j,xe,ye,path);  
        p=p->nextarc;               //p指向顶点v的下一条边顶点  
    }  
    visited[xi][yi]=0;  
}  
  
int main()  
{  
    ALGraph *G;  
    int mg[M+2][N+2]=                           //迷宫数组  
    {  
        {1,1,1,1,1,1},  
        {1,0,0,0,1,1},  
        {1,0,1,0,0,1},  
        {1,0,0,0,1,1},  
        {1,1,0,0,0,1},  
        {1,1,1,1,1,1}  
    };  
    CreateList(G,mg);  
    printf("迷宫对应的邻接表:\n");  
    DispAdj(G); //输出邻接表  
    PathType path;  
    path.length=0;  
    printf("所有的迷宫路径:\n");  
    FindPath(G,1,1,M,N,path);  
    return 0;  
}</span>  

运行结果:




### Java蓝桥杯迷宫问题真题及解法 #### 题目背景 蓝桥杯竞赛中的迷宫问题是典型的算法题目之一,通常涉及路径规划、遍历等内容。这类问题的核心在于如何利用数据结构和算法来模拟迷宫环境并找到最优解决方案。 --- #### 迷宫问题描述 根据引用内容[^2],蓝桥杯第十三届省赛中提到的迷宫问题可以总结如下: 给定一个二维字符矩阵表示的迷宫,其中 `*` 表示墙壁(不可通行),`1` 或其他特定符号表示可行走的道路,而未被标记的位置则默认为无法到达的区域。目标是从起点出发,计算能够达到终点的有效路径数量或者最短路径长度。 此类问题的关键点包括但不限于以下几个方面: - **输入处理**:读取迷宫的地布局。 - **状态定义**:明确当前节点的状态以及其可达性。 - **边界条件判断**:防止越界访问或重复访问同一位置。 - **搜索策略实现**:采用广度优先搜索 (BFS) 或深度优先搜索 (DFS),具体取决于题目需求。 以下是基于上述分析的一个通用解决框架: ```java import java.util.LinkedList; import java.util.Queue; public class MazeSolver { private static final char WALL = '*'; // 墙壁标志 private static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上下左右移动方向 public static boolean isValid(int x, int y, char[][] maze) { return x >= 0 && y >= 0 && x < maze.length && y < maze[0].length && maze[x][y] != WALL; } public static int shortestPath(char[][] maze, int startX, int startY, int endX, int endY) { Queue<int[]> queue = new LinkedList<>(); queue.add(new int[]{startX, startY}); int rows = maze.length; int cols = maze[0].length; int[][] distance = new int[rows][cols]; for (int i = 0; i < rows; ++i) Arrays.fill(distance[i], Integer.MAX_VALUE); distance[startX][startY] = 0; while (!queue.isEmpty()) { int[] currentPos = queue.poll(); int cx = currentPos[0]; int cy = currentPos[1]; if (cx == endX && cy == endY) break; for (int[] dir : DIRECTIONS) { int nx = cx + dir[0]; int ny = cy + dir[1]; if (isValid(nx, ny, maze)) { if (distance[nx][ny] > distance[cx][cy] + 1) { distance[nx][ny] = distance[cx][cy] + 1; queue.offer(new int[]{nx, ny}); } } } } return distance[endX][endY] == Integer.MAX_VALUE ? -1 : distance[endX][endY]; } public static void main(String[] args) { char[][] maze = { {'*', ' ', '*', ' '}, {' ', ' ', ' ', '*' }, {'*', ' ', '*', ' '} }; int result = shortestPath(maze, 0, 1, 2, 1); System.out.println(result); // 输出结果应为实际步数 } } ``` 此代码片段实现了基本的 BFS 方法用于求解迷宫中最短路径问题。它通过队列维护待探索节点,并逐步扩展直至抵达目的地为止。 --- #### 关键技术要点 1. **数据存储形式** 使用二维数组保存迷宫信息是最常见的做法,便于索引操作且直观易懂。 2. **搜索方法选择** 对于寻找最短路径场景推荐使用 BFS;如果仅需验证是否存在某种通路,则 DFS 可能更加高效简单[^3]。 3. **优化技巧** - 提前终止不必要的分支运算以提高效率。 - 利用记忆化手段避免冗余计算。 --- #### 总结 综上所述,在面对类似蓝桥杯这样的编程比赛中遇到有关迷宫类别的考题时,掌握好基础理论知识加上灵活运用各种工具将会事半功倍。以上提供了一个较为完整的思路指导及其对应实例演示供参考学习之用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值