计算机软件实习 项目三：A*算法迷宫自动寻路

已于 2023-10-07 21:28:30 修改
阅读量482 收藏 13
点赞数
文章标签： 算法 java 开发语言
于 2023-09-27 00:14:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67531703/article/details/133326183
版权

1.A*算法

A*算法

A*算法通过下面这个函数来计算每个节点的优先级。

其中：

  • f(n)是节点n的综合优先级。当我们选择下一个要遍历的节点时，我们总会选取综合优先级最高（值最小）的节点。
  • g(n) 是节点n距离起点的代价。
  • h(n)是节点n距离终点的预计代价，这也就是A*算法的启发函数。关于启发函数我们在下面详细讲解。

A*算法在运算过程中，每次从优先队列中选取f(n)值最小（优先级最高）的节点作为下一个待遍历的节点。

2.迷宫的生成算法

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

算法实现：

A*算法

这里f代表从起点开始到当前位置走过的步数，h表示当前节点到终点的曼哈顿距离，这样，总估价就是g=f+h，通过C++ stl中的优先队列进行维护；

bool flag=false;
QPair<int,int> pre[200][200];
int mpback[200][200];
struct node{
    int xnow,ynow,f,h,g;
    node(){
        xnow=ynow=f=h=g=0;
    }
    bool operator < (const node& tmp)const{
        return g<tmp.g;
    }
    node(int x,int y,int ft,int ht,int gt){
        xnow=x,ynow=y,f=ft,h=ht,g=gt;
    }
};
void mazeWidget::on_Astar_btn_clicked() {
    std::priority_queue<node> q;
    this->setFocus();
    if(flag)return;
    memset(pre,0,sizeof(pre));
    map->map[map->p_x][map->p_y]=5;
    memcpy(mpback,map->map,sizeof(map->map));
    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+dir[i][0],dy=tmpdata.ynow+dir[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=manha(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,b=pre[tmpx][tmpy].second;
        tmpx=a,tmpy=b;
    }
    map->map[map->start_x][map->start_y]=6;
    repaint();
    return;
}

运行结果：

在起点进行自动寻路

在移动过程中进行A*寻路

可以设置难度：

完整源代码：

maze.h

#ifndef MAZE_H
#define MAZE_H
#include <iostream>
/**************************************************
 * -1:边界 0:墙壁
 * 1:空单元(初始化后未判定的单元)
 * 2:待定墙壁(新建已定单元时建立)
 * 3:已定单元(确定迷宫树已延伸到的单元)
 * 4:打通墙壁(延伸操作)
 * 5.起点
 * 6.终点
 * 7.已经过路径
 * **************************************************/

class maze {
private:
    int para; 
    void base();
    void expandfunc(int i, int j);
    void start() ;
    bool judge();
    void judgement();
    void operation(int i, int j);
    void randomopt();
public:
    maze(int in_level);
    ~maze();
    //获取地图
    int start_x, start_y;   
    int getlevel() ;
    int map[200][200]; 
    int** getmap();
    int getside();
    void makemap();
    int p_x, p_y; 
    void rebuildmap();
    int* operator[](int index);
};
#endif // MAZE_H

maze.cpp

#include "maze.h"
void maze::base() {
    for (int i = 0; i < para * 2 + 1; i++) {
        for (int j = 0; j < para * 2 + 1; j++) {
            if (i == 0 || j == 0 || i == para * 2 + 1 - 1 ||
                j == para * 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:: expandfunc(int i, int j) {
    if (map[i - 1][j] == 0) {
        map[i - 1][j] = 2;
    }
    if (map[i + 1][j] == 0) {
        map[i + 1][j] = 2;
    }
    if (map[i][j - 1] == 0) {
        map[i][j - 1] = 2;
    }
    if (map[i][j + 1] == 0) {
        map[i][j + 1] = 2;
    }
}

void maze:: start() {
    map[start_x][start_y] = 5;
    expandfunc(start_x, start_y);
}

bool maze:: judge() {
    bool flag = 0;
    for (int i = 0; i < para * 2 + 1; i++) {
        for (int j = 0; j < para * 2 + 1; j++) {
            if (map[i][j] == 2) {
                flag = 1;
                return flag;
            }
        }
    }
    return flag;
}

void maze:: operation(int i, int j) {
    if ((map[i - 1][j] == 3 || map[i - 1][j] == 5) && map[i + 1][j] == 1) {
        map[i][j] = 4;
        map[i + 1][j] = 3;
        expandfunc(i + 1, j);
        start_x = i + 1;
        start_y = j;
    } else if ((map[i][j - 1] == 3 || map[i][j - 1] == 5) &&
               map[i][j + 1] == 1) {
        map[i][j] = 4;
        map[i][j + 1] = 3;
        expandfunc(i, j + 1);
        start_x = i;
        start_y = j + 1;
    } else if ((map[i + 1][j] == 3 || map[i + 1][j] == 5) &&
               map[i - 1][j] == 1) {
        map[i][j] = 4;
        map[i - 1][j] = 3;
        expandfunc(i - 1, j);
        start_x = i - 1;
        start_y = j;
    } else if ((map[i][j + 1] == 3 || map[i][j + 1] == 5) &&
               map[i][j - 1] == 1) {
        map[i][j] = 4;
        map[i][j - 1] = 3;
        expandfunc(i, j - 1);
        start_x = i;
        start_y = j - 1;
    } else {
        map[i][j] = 0;
    }
}
void maze::judgement(){
    if (!judge()) {
        map[start_x][start_y] = 6;
    }
    return;
}
void maze:: randomopt() {
    int t = 0;
    for (int i = 0; i < para * 2 + 1; i++) {
        for (int j = 0; j < para * 2 + 1; j++) {
            if (map[i][j] == 2) {
                t++;
            }
        }
    }
    int k = rand() % t + 1;
    t = 0;
    for (int i = 0; i < para * 2 + 1; i++) {
        for (int j = 0; j < para * 2 + 1; j++) {
            if (map[i][j] == 2) {
                t++;
                if (t == k) {
                    operation(i, j);
                    judgement();
                    return;
                }
            }
        }
    }

}
maze:: maze(int in_level):para(in_level) {
    start_x = 1, start_y = 1;
}
maze::~maze() {
}
int maze:: getlevel() {
    return maze::para;
}
int maze::getside() {
    return para * 2 + 1;
}
void maze:: makemap() {
    p_x = start_x;
    p_y = start_y;
    base();
    start();
    int a = 0;
    while (judge()) {
        a++;
        randomopt();
    }
}
int* maze::operator[](int index) {
    return map[index];
}
void maze::rebuildmap() {
    start_x = 1;
    start_y = 1;
    makemap();
}

mazewidget.h

#ifndef MAZEWIDGET_H
#define MAZEWIDGET_H

#include <QWidget>
#include <QMessageBox>   
#include <QPainter>        
#include <QDebug>           
#include <QKeyEvent>      
#include <QTimer>          
#include <QInputDialog>     
#include "maze.h"           

QT_BEGIN_NAMESPACE

namespace Ui {
class mazeWidget;
}
QT_END_NAMESPACE
class mazeWidget : public QWidget {
    Q_OBJECT
public:
    mazeWidget(QWidget* parent = nullptr);
    int manha(int x,int y);
    void print();
    ~mazeWidget();
protected:
    void paintEvent(QPaintEvent*);        
    void keyPressEvent(QKeyEvent*);       
private slots:
    void on_start_btn_clicked();    
    void on_stop_ptn_clicked();    
    void on_end_btn_clicked();      
    void on_setting_btn_clicked();  
    void on_Astar_btn_clicked();   
    void time_update();             
private:
    Ui::mazeWidget* ui;         
    maze* map;                  

    bool painting_switch;      
    bool timing_switch;         
    bool keybord_switch;       
    bool stop_switch;          

    int grade;                  
    int time;                   

    QTimer* timer;
};
#endif // MAZEWIDGET_H

 mazewidget.cpp

#include "mazewidget.h"
#include "ui_mazewidget.h"
#include <QVector>
#include <QThread>
#include <QPair>
#include <bits/stdc++.h>
#include <iostream>
int dir[4][2]={
    {0,-1},
    {0,1},
    {-1,0},
    {1,0}
};
bool flag=false;
QPair<int,int> pre[200][200];
int mpback[200][200];
struct node{
    int xnow,ynow,f,h,g;
    node(){
        xnow=ynow=f=h=g=0;
    }
    bool operator < (const node& tmp)const{
        return g>tmp.g;
    }
    node(int x,int y,int ft,int ht,int gt){
        xnow=x,ynow=y,f=ft,h=ht,g=gt;
    }
};
mazeWidget::mazeWidget(QWidget* parent)
    : QWidget(parent)
    , ui(new Ui::mazeWidget), map(new maze(20)), painting_switch(false), timing_switch(false)
    , keybord_switch(false), grade(0), time(0) {
    ui->setupUi(this);
    ui->progressBar->setVisible(false);
    ui->end_btn->setEnabled(false);
    ui->stop_ptn->setEnabled(false);
    ui->grade_value->setText("  ");
    ui->time_value->setText("  ");
    map->makemap();
    timer=new QTimer(this);
    connect(timer, &QTimer::timeout, this, &mazeWidget::time_update);
}
mazeWidget::~mazeWidget() {
    delete ui;
    delete map;
    delete timer;
}
void mazeWidget::paintEvent(QPaintEvent*) {
    if(!painting_switch) return;
    QPainter painter(this);     //画笔对象
    //绘图逻辑：
    int perblock = (std::min(ui->frame->width(), ui->frame->height()) - 20) / (map->getside());
    int start_x = ui->frame->x() + (ui->frame->width() - (ui->frame->x() + (map->getside()) * perblock)) / 2;
    int strat_y = ui->frame->y() + (ui->frame->height() - (ui->frame->y() + (map->getside()) * perblock)) / 2;
    for(int i = 0; i < map->getlevel() * 2 + 1; i++) {
        for(int j = 0; j < map->getlevel() * 2 + 1; j++) {
            if(i == map->p_x && j == map->p_y) {
                painter.fillRect(start_x + i * perblock, strat_y + j * perblock, perblock, perblock, QBrush(Qt::red));
            } else if(map->map[i][j] == 7) {
                painter.fillRect(start_x + i * perblock, strat_y + j * perblock, perblock, perblock, QBrush(Qt::yellow));
            } else if(map->map[i][j] == 3 || map->map[i][j] == 4) {
                painter.fillRect(start_x + i * perblock, strat_y + j * perblock, perblock, perblock, QBrush(Qt::gray));
            } else if(map->map[i][j] == 5) {
                painter.fillRect(start_x + i * perblock, strat_y + j * perblock, perblock, perblock, QBrush(Qt::blue));
            } else if(map->map[i][j] == 6) {
                painter.fillRect(start_x + i * perblock, strat_y + j * perblock, perblock, perblock, QBrush(Qt::green));
            } else {
                painter.fillRect(start_x + i * perblock, strat_y + j * perblock, perblock, perblock, QBrush(Qt::black));
            }
        }
    }
}
void mazeWidget::keyPressEvent(QKeyEvent* event) {
    if(!keybord_switch) return;
    int x = map->p_x;
    int y = map->p_y;
    map->map[x][y]=7;
    if(event->key() == Qt::Key_Up || event->key() == Qt::Key_W) {
        if((*map)[x][y - 1] == 3 || (*map)[x][y - 1] == 4 || (*map)[x][y - 1] == 5 || (*map)[x][y - 1] == 6 || (*map)[x][y - 1] == 7) {
            map->p_y--;
        }
    } else if(event->key() == Qt::Key_Down || event->key() == Qt::Key_S) {
        if((*map)[x][y + 1] == 3 || (*map)[x][y + 1] == 4 || (*map)[x][y + 1] == 5 || (*map)[x][y + 1] == 6 || (*map)[x][y + 1] == 7) {
            map->p_y++;
        }
    } else if(event->key() == Qt::Key_Left || event->key() == Qt::Key_A) {
        if((*map)[x - 1][y] == 3 || (*map)[x - 1][y] == 4 || (*map)[x - 1][y] == 5 || (*map)[x - 1][y] == 6 || (*map)[x - 1][y] == 7) {
            map->p_x--;
        }
    } else if(event->key() == Qt::Key_Right || event->key() == Qt::Key_D) {
        if((*map)[x + 1][y] == 3 || (*map)[x + 1][y] == 4 || (*map)[x + 1][y] == 5 || (*map)[x + 1][y] == 6 || (*map)[x + 1][y] == 7) {
            map->p_x++;
        }
    }
    if((*map)[map->p_x][map->p_y] != 5 && (*map)[map->p_x][map->p_y] != 6)(*map)[map->p_x][map->p_y] = 7;
    repaint();
    if((*map)[map->p_x][map->p_y] == 6) {
        map->makemap();
        repaint();
        flag=false;
        grade += pow(map->getlevel(), 2);
        ui->grade_value->setText(QString::number(grade));
    }
    map->map[map->p_x][map->p_y]=5;
}
void mazeWidget::time_update() {
    if(time != 0) {
        time--;
        ui->time_value->setText(QString::number(time));
        ui->progressBar->setValue(time / 2);
    } else {
        timer->stop();
        ui->progressBar->setVisible(false);
        keybord_switch = false;
        painting_switch = false;
        timing_switch = false;
        repaint();
        ui->start_btn->setEnabled(true);
        ui->time_value->setText(" ");
        ui->grade_value->setText(" ");
        ui->stop_ptn->setEnabled(false);
        ui->end_btn->setEnabled(false);
        ui->setting_btn->setEnabled(true);
        QMessageBox outgrade(QMessageBox::NoIcon, "恭喜", "您得分:" + QString::number(grade), QMessageBox::Ok);
        outgrade.exec();
        grade = 0;
    }
}
void mazeWidget::on_start_btn_clicked() {
    painting_switch = true;
    timing_switch = true;
    keybord_switch = true;
    flag=false;
    time = 200;
    this->setFocus();
    timer->start(1000);
    ui->progressBar->setVisible(true);
    ui->progressBar->setValue(100);
    ui->Astar_btn->setEnabled(true);
    repaint();
    ui->time_value->setText(QString::number(time));
    ui->grade_value->setText(QString::number(grade));
    ui->start_btn->setEnabled(false);
    ui->stop_ptn->setEnabled(true);
    ui->end_btn->setEnabled(true);
    ui->setting_btn->setEnabled(false);

}
void mazeWidget::on_stop_ptn_clicked() {
    this->setFocus();
    if(stop_switch) {
        timing_switch = false;
        keybord_switch = false;
        timer->stop();
        ui->stop_ptn->setText("继续");
        stop_switch = false;
    } else {
        timing_switch = true;
        keybord_switch = true;
        timer->start();
        ui->stop_ptn->setText("暂停");
        stop_switch = true;
    }
}
void mazeWidget::on_end_btn_clicked() {
    timing_switch = false;
    painting_switch = false;
    keybord_switch = false;
    stop_switch = false;
    timer->stop();
    this->setFocus();
    time = 0;
    grade = 0;
    ui->progressBar->setVisible(false);
    ui->grade_value->setText(" ");
    ui->time_value->setText(" ");
    ui->stop_ptn->setText("暂停");
    ui->stop_ptn->setEnabled(false);
    ui->end_btn->setEnabled(false);
    ui->start_btn->setEnabled(true);
    ui->setting_btn->setEnabled(true);
    ui->Astar_btn->setEnabled(false);
    map->rebuildmap();
    repaint();
}

void mazeWidget::on_setting_btn_clicked() {
    QStringList difficultys;
    this->setFocus();
    difficultys << tr("简单") << tr("普通") << tr("中等") << tr("困难");
    QString difficulty = QInputDialog::getItem(this, tr("选择难度"),
                         tr("请选择一个条目"), difficultys, 0, false);
    if(difficulty == tr("简单")) {
        delete map;
        map = new maze(5);
        map->makemap();
    } else if(difficulty == tr("普通")) {
        delete map;
        map = new maze(10);
        map->makemap();
    } else if(difficulty == tr("中等")) {
        delete map;
        map = new maze(20);
        map->makemap();
    } else if(difficulty == tr("困难")) {
        delete map;
        map = new maze(40);
        map->makemap();
    }
}
int mazeWidget::manha(int x,int y){
    return abs(x-map->start_x)+abs(y-map->start_y);
}
void mazeWidget::on_Astar_btn_clicked() {
    std::priority_queue<node> q;
    this->setFocus();
    if(flag)return;
    int len=map->getlevel();
    for(int i=0;i<=2*len;i++){
        for(int j=0;j<=2*len;j++){
            if(map->map[i][j]==7)
                map->map[i][j]=4;
        }
    }
    memset(pre,0,sizeof(pre));
    map->map[map->p_x][map->p_y]=5;
    memcpy(mpback,map->map,sizeof(map->map));
    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+dir[i][0],dy=tmpdata.ynow+dir[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=manha(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,b=pre[tmpx][tmpy].second;
        tmpx=a,tmpy=b;
    }
    map->map[map->start_x][map->start_y]=6;
    repaint();
    return;
}

main.cpp

#include "mazewidget.h"     
#include "maze.h"         
#include <QApplication>
#include <QStyleFactory>    

int main(int argc, char* argv[]) {
    srand(time(NULL));                              
    QApplication a(argc, argv);
    a.setStyle(QStyleFactory::create("Fusion"));    
    mazeWidget w;
    w.show();
    return a.exec();
}

 

 

 

duck_master
关注
  • 0
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
软件实习项目三：基于A*搜索算法迷宫游戏开发——代码
qq_50944418的博客
12-27 581
文章目录PMap.javaEMap.javaPaintMap.javaTest.javaAStarSolver.javaPoint.javaSolver.java PMap.java package gyt; import java.util.ArrayList; import javax.swing.JPanel; /**Prim算法： 让迷宫全都是墙。 选一个格，作为迷宫的通路，然后把它的邻墙放入列表。 当列表里还有墙时: 从列表里随机选一个墙，如果它对面的格子不
人工智能大作业——A*算法迷宫寻路问题
weixin_46037153的博客
07-05 2万+
项目设计的目的 利用A*算法实现迷宫寻路功能，利用启发式函数的编写以及各类启发式函数效果的比较。 相关原理知识介绍 A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。公式表示为：f(n)=g(n)+h(n)，其中f(n)是节点n从初始点到目标点的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取：估价值h(n)小于等于n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范
人工智能大作业——A算法迷宫寻路问题
最新发布
HUANGXIN9898的博客
06-20 484
A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。公式表示为：f(n)=g(n)+h(n)，其中f(n)是节点n从初始点到目标点的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取：估价值h(n)小于等于n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范围大，效率低，但能得到最优解。如果估价值大于实际值，搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。
A*算法求解迷宫寻路问题（启发式算法）
热门推荐
lazyn的博客
10-24 2万+
A*算法求解迷宫寻路问题 设置两种地图，两种启发式函数，分析不同起点终点，分析不同启发式函数，分析不同地图。
A*算法求解迷宫问题（算法讲解与证明、python实现与可视化）
m0_51653200的博客
12-26 1万+
A*算法是一种有序搜索算法，其特点在于对估价函数的定义上。对于一般的有序搜索，总是选择f值最小的节点作为扩展节点。因此，f是根据需要找到一条最小代价路径的观点来估算节点的，所以，可考虑每个节点n的估价函数值f(n)有两个分量：从起始节点到节点n的代价g(n)以及从节点n到达目标节点的代价h(n)，即f(n)=g(n)+h(n)。 迷宫问题是实验心理学中一个古典问题。迷宫从入口到出口可能有若干条通路，本实验要求求出从入口到出口的最短路径。
A*算法求解迷宫最短路问题（C++，VScode）
qq_52157037的博客
05-08 3163
A*算法求解迷宫最短路问题（C++实现）
迷宫求解最短路径（A*算法实现）
weixin_70339595的博客
06-22 3690
使用easyx库对迷宫地图进行窗口编辑，包含最短路径算法和多线程并发等相关代码。
计算机软件实习（三）A*算法迷宫实现
ShuraP的博客
12-20 355
A*算法迷宫实现 实验内容： （1） 迷宫游戏是非常经典的游戏，在该题中要求随机生成一个迷宫，并求解迷宫； （2）要求查找并理解迷宫生成的算法，并尝试用两种不同的算法来生成随机的迷宫。 （3）要求游戏支持玩家走迷宫，和系统走迷宫路径两种模式。玩家走迷宫，通过键盘方向键控制，并在行走路径上留下痕迹；系统走迷宫路径要求基于 A算法实现，输出走迷宫的最优路径并显示。设计交互友好的游戏图形界面。 （4） 选做：① 基于 A算法的八数码问题 简单思路： 1，把起始格添加到开启列表。 2，重复如下的工作： a) 寻找开
软件实习项目三：基于A*搜索算法迷宫游戏开发
qq_58247913的博客
12-15 1917
软件实习项目三：基于A*搜索算法迷宫游戏开发
软件实习实验三基于A*算法迷宫游戏开发
LLQ_007的博客
12-22 454
实验日志12.13 物联网一班-李林青-182210713120 源代码在Github： 实验任务 （1）迷宫游戏是非常经典的游戏，在该题中要求随机生成一个迷宫，并求解迷宫； （2）要求游戏支持玩家走迷宫，和系统走迷宫路径两种模式。玩家走迷宫，通过键盘方向键控制，并在行走路径上留下痕迹； （3）系统走迷宫路径要求基于A*算法实现，输出走迷宫的最优路径并显示。 （4）设计交互友好的游戏图形界面。 作品展示         进入游戏前的界面 &
实验三 基于A*算法的迷宫游戏
OJAC_hzx的博客
11-25 1105
一、实验目的 二、实验器材 三、实验内容 四、实验原理 五、实验步骤 六、实验具体过程 七、实验过程 八、实验结果分析
A*算法求解迷宫寻路问题
11-24
使用A*算法求解迷宫寻路问题，使用python编程，人工智能导论课后实验
迷宫 a*算法实现
02-07
迷宫 a*算法实现
迷宫问题A*算法
03-06
本科生计算机相关专业 人工智能课程 A*算法解决迷宫问题C++代码 详细注释，易懂
A*算法求解迷宫寻路问题实验
power_function的博客
09-05 2092
A* 搜索算法是一种启发式搜索算法。所谓启发式搜索算法，就是在盲目搜索算法中加入一个启发函数，在当前节点搜索完毕后，通过这个启发函数来进行计算，选择代价最少的节点作为下一步搜索的节点。通过这样的方式就能够找到最优解。DFSBFS这两种搜索方式都属于盲目的搜索方式，它不会在选择下一个节点的时候进行代价计算，而是按照一个固定的方式选择，这样在运气不好的情况，会对所有节点进行遍历。A* 搜索算法的核心就在于如何设计一个好的启发函数，启发函数的表达形式为：f(n)=g(n)+h(n)。
A*算法求解实验
TXQIHYJ的博客
12-04 929
通过本次实验，发现选用不同的启发函数，对于实验的结果有较大的影响。选用第一或第二种（也就是采用A*算法）远远优于普通的广度优先搜索，同时，明显的感觉到第二种启发函数效率更高，更快的找到最优解。但是，在实验过程中，也遇到了一些问题，比如初始值的八数码初始值的选择对于实验结果的影响很大，在选取一些样例时，比如，实验结果达到20000次依然没有停止，无法比较两种启发函数的优越性，鉴于时间原因，选取一些迭代次数较小就可以达到目标状态的样例进行验证，发现第二种结果优于第一种启发函数的结果。A*
实验三 基于A*算法寻路迷宫
weixin_45986866的博客
12-24 3449
代码如下
基于A*算法的迷宫寻路
qq_45492343的博客
01-10 798
迷宫生成和最优路径求解
A*算法解决迷宫寻路问题
u013300280的博客
12-08 5533
A*算法解决迷宫寻路问题 问题描述 下图是一个迷宫，试为机器人找一条从Start到End的最短路径设计一搜索算法 设计思路 a)状态空间的表示 首先将迷宫图转换为列表形式呈现，每个格子用 （横坐标，纵坐标，上通路状态，下通路状态，左通路状态，右通路状态）来表示，通路状态用1或0表示，可通过为1，不可通过为0。比如起点（1，1），假定不能从起点出去，所以（1,1）可以走下或走右，所以第一格的状态表示为（1,1,0,1,0,1）。 整张迷宫图的状态表示为： 同时每一步操作都记录在列表中，比如向下移动一格后，
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值