A*启发式搜索基础

最新推荐文章于 2024-04-16 13:53:10 发布
最新推荐文章于 2024-04-16 13:53:10 发布
阅读量114 收藏 2
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/ScratchingBear/p/5345842.html
版权

A*启发式搜索基础

传统的搜索方式是盲目搜索，即到每一步的时候并没有对每种情况进行有效的区分，这样的结果是浪费了大量的时间，对很多没有必要的数据进行了搜索。
而A*算法则在搜索的过程中会选取认为“最优”的状态进行搜索，而这正是这种算法的精华部分。

其实我们可以将他和Dijkstra进行一定的对比，他们的共同点很多，都是每次选取最优的点开始搜索，但是他们的“最优”策略不同也就决定了不同的效率。

  • Dijkstra是每次选取距离“出发点”最近的点开始搜索
  • A*算法则是选取距离“目标点”估计值最小的点开始搜索

注意这里的估计值就是A*算法的核心部分了，本博文最后会介绍和Dijkstra的具体效率的区别。

A*算法将点到重点的距离分为两个部分：

F(n)=G(n)+H(n)

介绍：

  • F(n)表示起点到目标的估计距离
  • G(n)表示起点到n点的准确距离
  • H(n)表示n点到目标点的估计距离

我们先假设从n点到目标点的准确距离为H′(n)，当然H′(n)的准确值我们并不知道，否则我们就不用费力气去求了。
这里H(n)需要满足的条件是

  • H(n)<=H′(n)

需要说明的是，我们A*搜索的核心就是H(n)的构建，最后构建的好坏直接决定了我们搜索的效率，我们的好是指：H(n)越贴近H′(n)越好，但是注意一定不能超过实际H′(n)的值。

为了和大多数的讲解名字对应，本博文采用相同名字，即名openlist的优先队列来存放需要搜索的内容，具体搜索步骤如下

  • 预定义H(n)=|beginx−endx|+|beginy−endy|
  • 预定义F(n)=G(n)+H(n)

  • openlist中F(n)值小的优先级别高

    1. 将起点加入openlist中
    2. 从队列中弹出元素
    3. 对弹出元素的周边进行搜索，如果发现有未被搜索到的位置，并且不是墙，河水，峡谷等不能行走的位置，则将其加入到队列中，并将其指向弹出元素。
      如果发现有已经被搜索过的位置，则查看其F(n)值是否比现在走到那个位置的F(n)值小，若现在是更优解，则更新其F(n)值。如果其不在队列中则把其重新加入队列，否则什么也不用做。
    4. 重复2-4步，直到找到目标点
    5. 最小路径即目标点的F(n)的值，同时根据维护的指针就可把最优路径推出来

补充：

我们从F(n)=G(n)+H(n)中可以推导出

  • 当G(n)=0时，算法相当与bfs；
  • 当H(n)=0时，算法相当于dfs；

自己写了一个示例代码如下：

@Frosero
#include <iostream>
#include <queue>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define INF 0x3f3f3f3f
using namespace std;


char mps[12][21] = {                              //x*
                    {"...................."},     //0
                    {"...S................"},     //1
                    {"...................."},     //2
                    {"...................."},     //3
                    {"....##########......"},     //4
                    {"...................."},     //5
                    {"...................."},     //6
                    {"...................."},     //7
                    {".............#......"},     //8
                    {".............#..P..."},     //9
                    {".............#......"},     //10
                    {"...................."},     //11
};              //原地图

const int beginx = 1,beginy = 3,endx = 9,endy = 16;
int link[12][21] = {0};           //1-up 2-right 3-down 4-left
int dx[] = {1,-1,0,0},dy[] = {0,0,1,-1},f[12][21]; //f用于储存F值

bool can_move(int x,int y){
    return x >= 0 && x < 12 && y >= 0 && y < 20 && mps[x][y] != '#';
}

class Node{
public:
    int x,y;
    int f,g,h;
    Node() = default;
    Node(int X,int Y,int G):x(X),y(Y),g(G) {
        this->h = abs(x - endx) + abs(y - endy) ; //计算H(n)
        this->f = this->g + this->h;
    }
    bool operator < (const Node &rhs) const {
        return this->f > rhs.f;
    }
};

void A_bfs(){
    for(int i=0;i<12;i++) for(int j=0;j<21;j++) f[i][j] = INF;
    priority_queue<Node> openlist;
    while(!openlist.empty()) openlist.pop();
    openlist.push(Node(beginx,beginy,0));
    f[beginx][beginy] = abs(beginx - endx) + abs(beginy - endy) ;
    while(!openlist.empty()){
        Node now = openlist.top(); openlist.pop();
        if(now.x == endx && now.y == endy) break;
        if(now.f > f[now.x][now.y]) continue;  //如果发现刚才记录的F值比现在实际F值小
                                            //说明该点已经被更新过，忽略即可
        for(int i=0;i<4;i++){
            int nx = now.x + dx[i];
            int ny = now.y + dy[i];
            if(can_move(nx,ny) && now.g + 1 + abs(nx - endx) + abs(ny - endy) < f[nx][ny]){
                mps[nx][ny] = mps[nx][ny] == 'P' ? 'P' : '*' ;
                f[nx][ny] = now.g + 1 + abs(nx - endx) + abs(ny - endy) ;
                if(nx == now.x + 1) link[nx][ny] = 1;
                else if(nx == now.x - 1) link[nx][ny] = 3;
                else if(ny == now.y + 1) link[nx][ny] = 4;
                else if(ny == now.y - 1) link[nx][ny] = 2;   //标记指针数组
                openlist.push(Node(nx,ny,now.g + 1));
            }
        }
    }
}


int main(){
    A_bfs();
    int x = endx,y = endy;
    while(1){
        if(link[x][y] == 1) x--;
        else if(link[x][y] == 2) y++;
        else if(link[x][y] == 3) x++;
        else if(link[x][y] == 4) y--;
        if(x == beginx && y == beginy) break;
        mps[x][y] = '+';
    }

    printf("ans is : %d\n",f[endx][endy]);
    for(int i=0;i<12;i++,printf("\n")){
        for(int j=0;j<20;j++) printf("%c",mps[i][j]);
    }

    return 0;
}

/*

输出：

ans is : 21
...*****............
..*S************....
..*+*************...
..*+************....
..*+##########***...
..*+++++++++++++**..
..*************+**..
...************+**..
....*********#*+**..
.....********#*+P...
......*.*...*#.*....
....................


符号解释
S:起点
P:目标点
*:搜索过的路径
+:搜索过的最优路径
#:墙

Process returned 0 (0x0)   execution time : 0.362 s
Press any key to continue.



*/

作为比较，我们用Dijkstra再做一次结果：

@Frosero
#include <iostream>
#include <queue>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define INF 0x3f3f3f3f
using namespace std;


char mps[12][21] = {                              //x*
                    {"...................."},     //0
                    {"...S................"},     //1
                    {"...................."},     //2
                    {"...................."},     //3
                    {"....##########......"},     //4
                    {"...................."},     //5
                    {"...................."},     //6
                    {"...................."},     //7
                    {".............#......"},     //8
                    {".............#..P..."},     //9
                    {".............#......"},     //10
                    {"...................."},     //11
};

const int beginx = 1,beginy = 3,endx = 9,endy = 16;
int link[12][21] = {0};           //1-up 2-right 3-down 4-left
int dx[] = {1,-1,0,0},dy[] = {0,0,1,-1},f[12][21];

bool can_move(int x,int y){
    return x >= 0 && x < 12 && y >= 0 && y < 20 && mps[x][y] != '#';
}

class Node{
public:
    int x,y;
    int g;
    Node() = default;
    Node(int X,int Y,int G):x(X),y(Y),g(G) { }
    bool operator < (const Node &rhs) const {
        return this->g > rhs.g;
    }
};

void A_bfs(){
    for(int i=0;i<12;i++) for(int j=0;j<21;j++) f[i][j] = INF;
    priority_queue<Node> openlist;
    while(!openlist.empty()) openlist.pop();
    openlist.push(Node(beginx,beginy,0));
    f[beginx][beginy] = 0 ;
    while(!openlist.empty()){
        Node now = openlist.top(); openlist.pop();
        if(now.x == endx && now.y == endy) break;
        for(int i=0;i<4;i++){
            int nx = now.x + dx[i];
            int ny = now.y + dy[i];
            if(can_move(nx,ny) && now.g + 1 < f[nx][ny]){
                mps[nx][ny] = mps[nx][ny] == 'P' ? 'P' : '*' ;
                f[nx][ny] = now.g + 1;
                if(nx == now.x + 1) link[nx][ny] = 1;
                else if(nx == now.x - 1) link[nx][ny] = 3;
                else if(ny == now.y + 1) link[nx][ny] = 4;
                else if(ny == now.y - 1) link[nx][ny] = 2;
                openlist.push(Node(nx,ny,now.g + 1));
            }
        }
    }
}


int main(){
    A_bfs();
    int x = endx,y = endy;
    while(1){
        if(link[x][y] == 1) x--;
        else if(link[x][y] == 2) y++;
        else if(link[x][y] == 3) x++;
        else if(link[x][y] == 4) y--;
        if(x == beginx && y == beginy) break;
        mps[x][y] = '+';
    }

    printf("ans is : %d\n",f[endx][endy]);
    for(int i=0;i<12;i++,printf("\n")){
        for(int j=0;j<20;j++) printf("%c",mps[i][j]);
    }

    return 0;
}

/*

输出：

ans is : 21
********************
***S++++++++++******
*************+******
*************++*****
****##########+*****
**************+*****
**************+*****
**************+*****
*************#+****.
*************#++P...
*************#**....
***************.....

符号解释
S:起点
P:目标点
*:搜索过的路径
+:搜索过的最优路径
#:墙

Process returned 0 (0x0)   execution time : 0.362 s
Press any key to continue.

*/

通过比较我们可以很轻松的发现A*搜索相比于Dijkstra的优越性

下面是在网上找的几组图片来进行一些对比
图片来源：[http://blog.csdn.net/luckyxiaoqiang/article/details/6996963]

例一

1. A*（曼哈顿距离）
这里写图片描述
2. A*（欧氏距离）
这里写图片描述
3. A*（切比雪夫距离）
这里写图片描述
4. Dijkstra
这里写图片描述
5. 双向BFS
这里写图片描述

例二

1. A*（曼哈顿距离）
这里写图片描述
2. A*（欧氏距离）
这里写图片描述
3. A*（切比雪夫距离）
这里写图片描述
4. Dijkstra
这里写图片描述
5. 双向BFS
这里写图片描述

例三

1. A*（曼哈顿距离）
这里写图片描述
2. A*（欧氏距离）
这里写图片描述
3. A*（切比雪夫距离）
这里写图片描述
4. Dijkstra
这里写图片描述
5. 双向BFS
这里写图片描述

例四

1. A*（曼哈顿距离）
这里写图片描述
2. A*（欧氏距离）
这里写图片描述
3. A*（切比雪夫距离）
这里写图片描述
4. Dijkstra
这里写图片描述
5. 双向BFS
这里写图片描述

 

转载于:https://www.cnblogs.com/ScratchingBear/p/5345842.html

weixin_30457465
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
迷宫搜索问题-利用启发式搜索 c++
03-22
使用C语言编写程序，解决迷宫搜索问题。本实验是基于启发式搜索算法，快速找到迷宫的出口，通过演示，可以清楚地展示基于状态空间搜索算法的工作流程，同时提供自动寻找路径的功能。
初识A*算法
billhu专栏
06-17 505
  初识A*算法                                                    Sunway 　　 目 录 　　1 何谓启发式搜索算法 　　2 初识A*算法
记录：A星算法
m0_58138380的博客
04-21 460
A*算法、八数码问题
深入A*算法(by sunway)
04-07 1101
一、前言　　在这里我将对A*算法的实际应用进行一定的探讨，并且举一个有关A*算法在最短路径搜索的例子。值得注意的是这里并不对A*的基本的概念作介绍，如果你还对A*算法不清楚的话，请看姊妹篇《初识A*算法》。　　这里所举的例子是参考AMIT主页中的一个源程序，使用这个源程序时，应该遵守一定的公约。二、A*算法的程序编写原理　　我在《初识A*算法》中说过，A*算法是最好优先算法的一种。
基于A*启发式搜索解决迷宫问题
qq_45347185的博客
06-26 4268
这里写自定义目录标题一、实验目的二、实验要求三、实验内容四、实验步骤1. 状态表示2. 启发函数3. 搜索过程4. 实验结果5. 分析与讨论五、代码六、参考文献 一、实验目的 1、使学生加深对图搜索技术的理解 2、掌握图搜索基本编程方法 3、运用图搜索技术解决一些应用问题 二、实验要求 1、用启发式搜索算法实现路径规划问题。 2、 有明确的状态空间表达，规则集以及估计函数。 3、 程序运行时，应能清晰直观演示搜索过程。 三、实验内容 机器人路径规划问题：左上角为坐标原点，水平向右为 x 轴方向，竖直向下为y
a*启发式搜索算法的matlab仿真程序
12-29
**a*启发式搜索算法** 是一种在图形搜索问题中广泛应用的优化算法，它结合了最佳优先搜索（如Dijkstra算法）与启发式信息，旨在更有效地找到从起点到目标节点的最短路径。该算法引入了估计代价函数，通过评估每个...
A*算法的基础上修改成可放缩路径长度的A*
10-16
A*（A-star）算法是一种在图形搜索中广泛使用的路径查找算法，它的核心思想是结合了最佳优先搜索（如Dijkstra算法）与启发式搜索。A*算法通过一个估计函数来预测从起点到目标点的总成本，这个函数通常称为启发式函数...
A星搜索算法教程确定目标最短路径的A*搜索算法教程
01-03
A*算法结合了Dijkstra算法的全局最优性和 greedy最佳优先搜索算法的局部最优性，通过评估函数(f(n) = g(n) + h(n))来指导搜索方向，其中g(n)表示从起点到当前节点的实际代价，h(n)是当前节点到目标节点的启发式估计...
基于matlab的双向A*算法
04-30
A*算法（A-Star）是一种广泛应用的启发式搜索算法，它结合了Dijkstra算法的最优化路径寻找与启发式信息的高效性。而基于MATLAB实现的双向A*算法，则是A*算法的一种优化形式，旨在进一步提升路径规划的效率。 首先，...
利用a*启发式搜索解决迷宫寻路问题
weixin_44182128的博客
07-18 1896
利用a+启发式搜索解决迷宫寻路问题一、a+启发式搜索是什么？见另一博主博文A星算法详解(个人认为最详细,最通俗易懂的一个版本)_Colin丶的博客-CSDN博客_a星算法A*寻路算法原文地址http//www.gamedev.net/reference/articles/article2003.asp概述虽然掌握了A*算法的人认为它容易，但是对于初学者来说，A*算法还是很复杂的。搜索区域(TheSearchArea)我们假设某人要从A点移动到B点，但是这两点之间被一堵墙隔开。(0,0)...........
人工智能实验_搜索策略_迷宫.zip
03-26
通过启发式搜索实现了迷宫问题的求解。可根据设置的起点和终点找到最优路径。参考A*算法核心代码，实现A*算法的求解程序，两种不同的估价函数。 针对不同的估价函数，求得问题的解
A*算法搜索实现迷宫
10-29
A*算法是人工智能中的一种搜索算法，是一种启发式搜索算法，它不需遍历所有节点，只是利用包含问题启发式信息的评价函数对节点进行排序，使搜索方向朝着最有可能找到目标并产生最优解的方向。
A*算法求解迷宫寻路问题（启发式算法）
12-04
入口坐标和出口坐标分别为(startx,starty)和(endx,eny)，每一个坐标点有两种可能：0或1，其中0表示该位置允许通过，1表示该位置不允许通过。以寻路问题为例实现A*算法的求解程序，设计两种不同的估价函数。
人工智能 - A*算法解决迷宫问题 附源码和可视化显示
SCY164759920的博客
12-31 3713
人工智能 - A*算法解决迷宫问题 附源码和可视化显示
算法——启发式搜索
最新发布
m0_60697583的博客
04-16 818
通过设计适当的启发式函数，可以在大规模的搜索空间中快速找到接近最优解的解决方案。启发式搜索是一类基于估计值（启发式函数）来指导搜索的算法，常见的有 A* 算法。：启发式搜索在游戏博弈中有着广泛的应用，例如在国际象棋、围棋、扑克等游戏中。其原理是在搜索过程中，不仅仅考虑当前的搜索状态，还利用一定的启发式信息来指导搜索方向，从而更加高效地达到目标状态。：启发式搜索还可以用于智能体的决策问题，例如在强化学习中，智能体可以使用启发式搜索来选择动作以最大化累积奖励。
解密迷宫问题：三种高效算法Java实现，让你轻松穿越未知迷宫
xxxzzzqqq_的博客
04-26 4765
我们总结一下，在迷宫问题中，深度优先搜索（DFS）、广度优先搜索（BFS）和 A* 都可以用来寻找最短路径或最优解。空间要求低，不需要保存整个搜索树，只需要保存当前路径；所有解的路径长度差别不大，或者只需要找到其中一个解；迷宫比较大，而且有很多死路，采用 DFS 可以快速探索大面积空间。需要找到最短路径或最优解；迷宫中大部分路径长度差别不大；可以承受较大的空间复杂度，需要保存整个搜索树。需要找到最短路径或最优解；需要考虑迷宫中的障碍物，即寻找一条避开障碍物的路径；
迷宫问题 解题报告
zyf2000
08-13 3746
迷宫问题 【问题描述】 设有一个N*N方格的迷宫，入口和出口分别在左上角和右上角。迷宫格子中分别放有0和1，0表示可通，1表示不能，迷宫走的规则：即从某点开始，有八个方向可走，前进方格中数字为0时表示可通过，为1时表示不可通过，要另找路径。入口和出口处肯定是0； 编程找出从入口（左上角）到出口（右上角）的路径（不能重复），输出路径总数。如果不能到达，则输出0； 【输入样例】 3 0 0
一种使 Dijkstra A* 规划出来的路径更平滑的方法
热门推荐
qq_29796781的博客
04-27 1万+
    我们知道一般用Dijkstra A* 等路径规划算法规划出来的路径都不是很平滑的   机器人沿着这些不平滑路径驾驶，效果差强人意，为了时机器人能自然的沿着给定路径行驶，必须对路径点做平滑处理 如上图  S表示路线规划的起点， E表示路线规划的重点 ，蓝色的线为路线规划 Dijkstra A*规划出来的路路线，但在实际行驶中，车辆不可能遇到大拐弯原地停下后转个90度的大弯，不仅可操作性...
A*算法：最优启发式搜索策略与伪代码
最优搜索算法——A*算法是一种启发式搜索方法，用于在图或状态空间中寻找从起点到终点的最短路径或最优解决方案。它是在传统的A算法基础上进行改进，特别强调了引入启发式信息的重要性。 启发式搜索是针对盲目搜索...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值