【C++】使用队列求迷宫最短路径

本文介绍了一个使用C++实现的迷宫最短路径寻找算法。通过创建迷宫数组并利用队列来找到从起点到终点的最短路径。文章详细展示了如何定义迷宫结构、移动方向及路径追踪。

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

#include <iostream>
#include <stdlib.h>

#define num  1024
using namespace std;
typedef struct node{
    int x,y;
    int pre;	//指向前驱点的坐标
}SqType;

typedef struct{
    int x,y;
}item;

/*创建迷宫数组*/
int** CreateMaze(int **maze,int m,int n){
    //初始化数组
    for(int i=0;i<m+2;i++){
        for(int j=0;j<n+2;j++){
            maze[i][j]=1;
        }
    }

    //给数组赋值
    for(int k=1;k<m+1;k++){
        for(int q=1;q<n+1;q++){
            int x;
            //cout<<"please enter "<<'('<<k<<","<<q<<')'<<" number:";
            cin>>x;
            maze[k][q]=x;
        }
    }
    return maze;
}

/*定义在不同方向上坐标的变化*/
item assignMove(item moveEle[8]){
    for (int i = 0; i < 8; i++)
    {
        switch(i){
                case 0:moveEle[0].x=1;moveEle[0].y=0;break;
                case 1:moveEle[1].x=1;moveEle[1].y=1;break;
                case 2:moveEle[2].x=0;moveEle[2].y=1;break;
                case 3:moveEle[3].x=-1;moveEle[3].y=1;break;
                case 4:moveEle[4].x=-1;moveEle[4].y=0;break;
                case 5:moveEle[5].x=-1;moveEle[5].y=-1;break;
                case 6:moveEle[6].x=0;moveEle[6].y=-1;break;
                case 7:moveEle[7].x=1;moveEle[7].y=-1;break;
            }
    }
    return moveEle[8];
}

/*打印路线*/
void printPath(SqType *sq,int rear){
    int i=rear;
    while(i!=-1){
        cout<<sq[i].x<<" "<<sq[i].y<<" "<<endl;
        i=sq[i].pre;
    }
}

/*利用队列求最短路径*/
void path(int **maze,int m,int n){  //*((int*)pia3 + i * 4 + j)
    item moveEle[8];
    moveEle[8]=assignMove(moveEle);

    SqType sq[num];
        int front,rear;
        int x,y,i,j,v;
        sq[0].x=1;sq[0].y=1;sq[0].pre=-1;
        front=rear=0;
        maze[1][1]=-1;  //标记已经过的位置
        while(front<=rear){
            x=sq[front].x;y=sq[front].y;
            for(v=0;v<8;v++){
                i=x+moveEle[v].x;j=y+moveEle[v].y;
                if(maze[i][j]==0){
                    rear++;
                    sq[rear].x=i;sq[rear].y=j;sq[rear].pre=front;
                    maze[i][j]=-1;
                }
                if(i==m && j==n){
                    printPath(sq,rear); //打印路线
                }
            }
            front++;
        }
}


int main()
{
    int m,n;
    cout<<"row:";
    cin>>m;
    cout<<"column:";
    cin>>n;
    
    //创建迷宫数组
    int **maze=new int *[m+2];
    for (int i = 0; i < m+2; i++)
    {
        maze[i]=new int[n+2];
    }
    maze=CreateMaze(maze,m,n);
    
    //寻找迷宫最短路径
    path(maze,m,n);
    system("pause");
    return 0;
}

好的,让我来回答你的问题。 首先,创建迷宫可以用二维数组来表示,其中每个格子的值表示该位置是通道还是墙壁(可以用0表示通道,1表示墙壁)。如下所示: int maze[ROWS][COLS] = { {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, {1, 0, 0, 0, 1, 0, 0, 0, 0, 1}, {1, 0, 1, 0, 1, 0, 1, 1, 0, 1}, {1, 0, 1, 0, 0, 0, 0, 1, 0, 1}, {1, 0, 1, 1, 1, 1, 0, 1, 0, 1}, {1, 0, 0, 0, 0, 1, 0, 1, 0, 1}, {1, 1, 1, 1, 0, 0, 0, 1, 0, 1}, {1, 0, 0, 0, 0, 1, 1, 1, 0, 1}, {1, 0, 1, 1, 0, 0, 0, 0, 0, 1}, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1} }; 其中,ROWS和COLS分别表示迷宫的行数和列数。 其次,我们可以用广度优先搜索算法(BFS)解从指定入口到出口的所有路径,并用队列最短路径。BFS算法的基本原理是从起点开始,先访问它的所有邻居节点,然后再访问邻居节点的邻居节点,以此类推,直到找到终点或者所有节点都被访问为止。 下面是最短路径的代码示例: #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 #define ROWS 10 #define COLS 10 #define INFINITY 1000000 typedef struct { int i, j; //位置 } PosType; typedef struct { int ord; //通道块的“权值”,即从起点到此位置的步数 PosType seat; //位置 int dir; //下一步的方向 } ElemType; typedef struct { ElemType *base; int front, rear; } Queue; void InitQueue(Queue *Q) { Q->base = (ElemType *)malloc(MAXSIZE * sizeof(ElemType)); Q->front = Q->rear = 0; } void EnQueue(Queue *Q, ElemType e) { if ((Q->rear+1)%MAXSIZE == Q->front) { printf("队列已满!\n"); return; } Q->base[Q->rear] = e; Q->rear = (Q->rear+1)%MAXSIZE; } ElemType DeQueue(Queue *Q) { ElemType e; if (Q->front == Q->rear) { printf("队列为空!\n"); exit(0); } e = Q->base[Q->front]; Q->front = (Q->front+1)%MAXSIZE; return e; } int Maze[ROWS][COLS] = { // 迷宫 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, {1, 0, 0, 0, 1, 0, 0, 0, 0, 1}, {1, 0, 1, 0, 1, 0, 1, 1, 0, 1}, {1, 0, 1, 0, 0, 0, 0, 1, 0, 1}, {1, 0, 1, 1, 1, 1, 0, 1, 0, 1}, {1, 0, 0, 0, 0, 1, 0, 1, 0, 1}, {1, 1, 1, 1, 0, 0, 0, 1, 0, 1}, {1, 0, 0, 0, 0, 1, 1, 1, 0, 1}, {1, 0, 1, 1, 0, 0, 0, 0, 0, 1}, {1, 1, 1, 1, 1, 1, 1, 1, 1, 1} }; int visit[ROWS][COLS]; // 记录迷宫中的点是否已访问过 Queue Q; // 队列 // 初始化visit void initVisit() { int i, j; for(i=0; i<ROWS; i++) { for(j=0; j<COLS; j++) { visit[i][j] = 0; } } } // i,j是当前迷宫中的位置,dir是从上一个位置到达这个位置需要的方向 // dir=0表示从上一个位置往上,dir=1表示从上一个位置往右,... void Visit(int i, int j, int dir, int step, PosType *end) { if (i == end->i && j == end->j) { // 到达终点 printf("从出口到入口的路径如下:\n"); PrintPath(i, j); printf("\n从出口到入口的最短路径长度为:%d\n", step); exit(0); } visit[i][j] = 1; // 标记当前位置已访问 ElemType e; e.ord = step; e.seat.i = i; e.seat.j = j; e.dir = dir; EnQueue(&Q, e); // 进队列 } void BFS(PosType start, PosType end) { // 八个方向:上、下、左、右、左上、右上、左下、右下 int di[8] = {-1,1,0,0,-1,-1,1,1}; int dj[8] = {0,0,-1,1,-1,1,-1,1}; int i, j, Line; // 按层序号逐个访问 ElemType e; visit[start.i][start.j] = 1; e.ord = 0; e.seat = start; e.dir = 0; EnQueue(&Q, e); while (Q.front != Q.rear) { e = DeQueue(&Q); // 出队列 i = e.seat.i; // 取出位置信息 j = e.seat.j; Line = e.ord; // 枚举8个方向上的可行的下一个位置 for (int k = 0; k < 8; k++) { int ni = i + di[k]; int nj = j + dj[k]; if (Maze[ni][nj] == 0 && visit[ni][nj] == 0) { // 如果下一个位置是通道,并且没有被访问过 Visit(ni, nj, k, Line+1, &end); // 如果当前位置是终点则结束搜索,输出路径并退出程序 } } } } // 回溯法输出路径 void PrintPath(int i, int j) { ElemType position[ROWS*COLS]; int top = -1; ElemType e; e.seat.i = i; e.seat.j = j; e.ord = -1; // 标记为路径上的点 position[++top] = e; while (top >= 0) { e = position[top--]; if (e.ord == -1) { printf("(%d,%d) ", e.seat.i, e.seat.j); } else { printf("(%d,%d)->", e.seat.i, e.seat.j); } if (top >= 0 && position[top].ord == e.ord-1) { continue; } // 查找e的前驱位置 int k; for (k = 0; k < 8; k++) { if ((e.dir+6)%8 == k || (e.dir+7)%8 == k || (e.dir+8)%8 == k) { continue; } int ni = e.seat.i + di[k]; int nj = e.seat.j + dj[k]; if (visit[ni][nj] == 1 && e.ord-1 == Q.base[visitToQueue(ni,nj)].ord) { break; } } if (k < 8) { // e有前驱位置 ElemType pre; pre.seat.i = e.seat.i + di[k]; pre.seat.j = e.seat.j + dj[k]; pre.ord = e.ord - 1; pre.dir = k; position[++top] = pre; } } } int visitToQueue(int i, int j) { int k; for (k = Q.front; k != Q.rear; k=(k+1)%MAXSIZE) { if (Q.base[k].seat.i == i && Q.base[k].seat.j == j) { return k; } } } int main() { PosType start = {1, 1}; PosType end = {ROWS-2, COLS-2}; InitQueue(&Q); initVisit(); BFS(start, end); printf("没有可行路径!\n"); return 0; } 需要注意的是,以上代码中的PrintPath函数使用了回溯法输出路径,而visitToQueue函数用于将visit数组中的位置与队列中的元素对应起来。这样,我们就可以解从指定入口到出口的所有路径,并用队列最短路径了。 希望我的回答能够帮助到你,如果还有不明白的地方,请随时提问!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柳叶lhy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值