随机迷宫生成与A*算法在自动寻路中的应用-CSDN博客

本文链接：https://blog.csdn.net/Maktub_syh/article/details/133364719

1.随机迷宫生成算法

首先，将地图分割成若干相互隔离的小格，将起点设置成扩展状态，然后从起点开始，向外进行扩展，同时使用随机函数选择一个可行的墙面进行打通，这样就构成了迷宫的地图

迷宫随机生成算法部分代码：

//生成基础地图（单元格）
void maze::base() {
    for (int i = 0; i < level * 2 + 1; i++) {
        for (int j = 0; j < level * 2 + 1; j++) {
            if (i == 0 || j == 0 || i == level * 2 + 1 - 1 || j == level * 2 + 1 - 1) {
                map[i][j] = -1;            //边界
            } else if (i % 2 != 0 && j % 2 != 0) {
                map[i][j] = 1;            //空  初始化后未判定
            } else {
                map[i][j] = 0;             //墙壁
            }
        }
    }
}

void maze:: random() {
    int t = 0;
    for (int i = 0; i < level * 2 + 1; i++) {
        for (int j = 0; j < level * 2 + 1; j++) {
            if (map[i][j] == 2) {
                t++;
            }
        }
    }
    int k = rand() % t + 1;
    t = 0;
    for (int i = 0; i < level * 2 + 1; i++) {
        for (int j = 0; j < level * 2 + 1; j++) {
            if (map[i][j] == 2) {
                t++;
                if (t == k) {
                    opera(i, j);
                    goto arrive;
                }
            }
        }
    }
arrive:
    if (!judge()) {
        map[start_x][start_y] = 6;
    }
}

2.A*算法自动寻路

定义

A*算法，A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。

定义解析

A*算法是一个“搜索算法”，实质上是广度优先搜索算法（BFS）的优化。从起点开始，首先遍历起点周围邻近的点，然后再遍历已经遍历过的点邻近的点，逐步的向外扩散，直到找到终点。
A*算法的作用是“求解最短路径”，如在一张有障碍物的图上移动到目标点，以及八数码问题（从一个状态到另一个状态的最短途径）
A*算法的思路类似图的Dijkstra算法，采用贪心的策略，即“若A到C的最短路径经过B，则A到B的那一段必须取最短”，找出起点到每个可能到达的点的最短路径并记录。

void mazeWidget::on_search_btn_clicked() {
    std::priority_queue<node> q;  //考虑寻找最短路径的节点
    this->setFocus();
    if(flag)return;
    map->map[map->p_x][map->p_y]=5;
    memcpy(mpback,map->map,sizeof(map->map));   //map内容复制给mpback
    q.push(node(map->p_x,map->p_y,0,0,0));
    while(q.size()){
        node tmpdata=q.top();
        q.pop();
        for(int i=0;i<4;i++){
            int dx=tmpdata.xnow+direct[i][0];
            int dy=tmpdata.ynow+direct[i][1];
            if(mpback[dx][dy]==0||mpback[dx][dy]==-1||mpback[dx][dy]==9)continue;
            pre[dx][dy]=qMakePair(tmpdata.xnow,tmpdata.ynow);
            if(mpback[dx][dy]==6){
                flag=true;
                break;
            }
            mpback[dx][dy]=9;        //已检测，不再考虑
            node topush;
            topush.xnow=dx,topush.ynow=dy;
            topush.f=tmpdata.f+1;
            topush.h=mahan(dx,dy);
            topush.g=topush.h+topush.f;
            q.push(topush);
        }
        if(flag) break;
    }
    int tmpx=map->start_x,tmpy=map->start_y;

    while(map->map[tmpx][tmpy]!=5){  //回溯
        map->map[tmpx][tmpy]=5;
        int a=pre[tmpx][tmpy].first;
        int b=pre[tmpx][tmpy].second;
        tmpx=a,tmpy=b;
    }
    map->map[map->start_x][map->start_y]=6;
    repaint();
    return;
}