Astar算法 A星算法

已于 2023-08-21 18:37:06 修改
阅读量818 收藏
点赞数
分类专栏： 算法 A星算法 文章标签： 算法
于 2023-08-21 18:28:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74372356/article/details/132414136
版权

​​​​​​​​​​​​​https://blog.csdn.net/jj6666djdbbd/article/details/126287486?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522169261313816800213024970%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=169261313816800213024970&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_click~default-2-126287486-null-null.142^v93^chatgptT3_1&utm_term=a%E6%98%9F%E7%AE%97%E6%B3%95&spm=1018.2226.3001.4187

 

前几天跟着这个教程学了A星算法，发现如果遇到规模大且复杂的地图，识别速度会非常慢，个人认为是一个格子会被周围八个点进行反复搜索导致的，因此改进了算法，识别效率大幅提升，还做了个可视化，大家可以参考

#include<vector>
#include <iostream>
#include<cstring>
#include<stdlib.h>
#include<Windows.h>

#define ROWS 20  //二十行二十列
#define COLS 20
#define ZXDJ 10  //直线和斜线代价  
#define XXDJ 14

enum dirent { p_up, p_dowm, p_left, p_right, p_lup, p_rup, p_ldowm, p_rdowm }; //枚举

using namespace std;

//定义地图上的点
struct point
{
    int x=0, y=0;           //数组下标，表示地图中位置
    int f=0, g=0, h=0;      //量化评估
};

struct treeNode {           //树的节点
    point pos;
    vector<treeNode*> child;    //父有多子
    treeNode* pParent = NULL;   //子有一父 
};

//创建树节点的函数
treeNode* createTreeNode(int x, int y)
{
    treeNode* pNew = new treeNode;
    treeNode tlist = { 0 };  //初始化，将内存全部赋值为0，即NULL

    pNew->pos.x = x;
    pNew->pos.y = y;
    return pNew;
}

void FindAroundPoint(int i, treeNode* pChild)
{
    switch (i)
    {
    case p_up:
        if (pChild->pos.x == 0)
        {
            break;
        }
        pChild->pos.x--;    //如果往上走，x-1
        pChild->pos.g += ZXDJ;
        break;
    case p_dowm:
        if (pChild->pos.x == 19)
        {
            break;
        }
        pChild->pos.x++;    //如果往下走，x+1
        pChild->pos.g += ZXDJ;
        break;
    case p_left:
        if (pChild->pos.y == 0)
        {
            break;
        }
        pChild->pos.y--;    //如果往左走，y-1
        pChild->pos.g += ZXDJ;
        break;
    case p_right:
        if (pChild->pos.y == 19)
        {
            break;
        }
        pChild->pos.y++;    //如果往右走，y+1
        pChild->pos.g += ZXDJ;
        break;
    case p_lup:
        if (pChild->pos.x == 0 ||pChild->pos.y == 0)
        {
            break;
        }
        pChild->pos.x--;    //如果往左上走，x-1,y-1
        pChild->pos.y--;
        pChild->pos.g += XXDJ;
        break;
    case p_rup:
        if (pChild->pos.x == 0 || pChild->pos.y == 19)
        {
            break;
        }
        pChild->pos.x--;    //如果往右上走，x-1,y+1
        pChild->pos.y++;
        pChild->pos.g += XXDJ;
        break;
    case p_ldowm:
        if (pChild->pos.x == 19 || pChild->pos.y == 0)
        {
            break;
        }
        pChild->pos.x++;    //如果往左下走，x+1,y-1
        pChild->pos.y--;
        pChild->pos.g += XXDJ;
        break;
    case p_rdowm:
        if (pChild->pos.x == 19 || pChild->pos.y == 19)
        {
            break;
        }
        pChild->pos.x++;    //如果往右下走，x+1,y+1
        pChild->pos.y++;
        pChild->pos.g += XXDJ;
        break;
    }
}

//计算当前点与终点的曼哈顿距离
int getH(point pos, point endPos) 
{
    int x, y;

    if (endPos.x > pos.x)
        { x = endPos.x - pos.x; }
    else{ x = pos.x - endPos.x; }

    if (endPos.y > pos.y)
        { y = endPos.y - pos.y; }
    else { y = pos.y - endPos.y; }

    return ZXDJ * (x + y);
}

void print3(int map[ROWS][COLS], int row, int col, point begin, point end ,treeNode *pCurrent) //在cmd中输出路径
{
    int i = 0;
    int j = 0;

    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            // cmd该颜色句柄
            HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);  
            // 获取当前文本属性
            CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
            GetConsoleScreenBufferInfo(hConsole, &consoleInfo);
            WORD originalAttributes = consoleInfo.wAttributes;

            if (map[i][j] == 1)    //墙
            {
                SetConsoleTextAttribute(hConsole,BACKGROUND_BLUE | FOREGROUND_INTENSITY);  //蓝墙
            }

            if (map[i][j] == 2)    //搜索过的点
            {
                // 设置新的文本属性，可以选择以下颜色组合
                // FOREGROUND_RED, FOREGROUND_GREEN, FOREGROUND_BLUE,
                // FOREGROUND_INTENSITY, BACKGROUND_RED, BACKGROUND_GREEN,
                // BACKGROUND_BLUE, BACKGROUND_INTENSITY
                SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_INTENSITY);    //红字
            }

            if (map[i][j] == 3)     //最终路径
            {
                SetConsoleTextAttribute(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);  //绿字
            }

            if ((begin.x == i && begin.y == j) || (end.x == i && end.y == j))    //起点终点
            {
                SetConsoleTextAttribute(hConsole, BACKGROUND_GREEN | BACKGROUND_INTENSITY);   //浅蓝墙
            }

            printf("%d ", map[i][j]);

            // 恢复原始文本属性
            SetConsoleTextAttribute(hConsole, originalAttributes);
        }
        printf("\n");
    }
}

void IsFindEnd(bool isFindEnd, int map[ROWS][COLS], point begPos, point endPos, treeNode* pCurrent)
{
    if (isFindEnd)
    {
        printf("找到终点\n");
        printf("路径");
        while (pCurrent)   //打印路径的点
        {
            printf("(%d,%d)", pCurrent->pos.x, pCurrent->pos.y);
            map[pCurrent->pos.x][pCurrent->pos.y] = 3;  //最终路径会在可视化时显示3
            pCurrent = pCurrent->pParent;  //往上走,子走到父
        }
        printf("\n");
    }
    else
    {
        printf("未找到终点\n");   
    }
    print3(map, ROWS, COLS, begPos, endPos, pCurrent); //可视化
}

int main()
{
    int map[ROWS][COLS] = {
        { 0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 }, //4
        { 0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }, //8
        { 0,1,1,1,1,1,1,1,0,0,1,0,0,1,1,1,1,1,0,0 },
        { 0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,0,0,1,0,0 },
        { 0,0,0,0,0,1,0,1,0,0,1,1,1,1,1,1,0,1,1,1 },
        { 1,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0 }, //12
        { 1,0,0,0,0,1,0,1,1,1,1,0,0,0,0,1,0,0,0,0 },
        { 1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 1,0,0,0,1,1,1,1,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 1,1,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0 }, //16
        { 1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0 },
        { 1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0 },
        { 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0 },
        };

    point begPos = { 0,0 };
    point endPos = { 8,8 };

    bool pathMap[ROWS][COLS] = { 0 }; //走过的地图,虚拟地图，全false，走过标记1(true)
     
    //  准备一棵树，从起点开始，循环寻路，找出周围能走的点，入树，入容器，
    //  挑出数组中f最小的点，走，遇终点或没终点：停，显示路径
    

    treeNode* pRoot = createTreeNode(begPos.x, begPos.y);  //起点是树的根节点
    pathMap[begPos.x][begPos.y] = true;                    //虚拟地图里标记起点已经走过
    
    treeNode* pCurrent = pRoot;      //当前点
    treeNode* pChild = NULL;         //根节点的孩子
    treeNode* tmp3 = NULL;           //临时节点
    
    //准备一个数组,用来存周围一圈的点
    vector<treeNode*>buff;
    vector<treeNode*>::iterator it;             //变化的迭代器
    vector<treeNode*>::iterator itMin;          //记录最小的
    vector<treeNode*>::iterator tmp2;

    bool isFindEnd = false;

    int o = 0;  //用来打印走了几次
    int k = 0;  //用来判断搜索到的点是否在buff存在，是否需要计算

    while (1)
    {
        //找出周围能走的点8个
        for (int i = 0; i < 8; i++)
        {

            pChild = createTreeNode(pCurrent->pos.x, pCurrent->pos.y);  //创建出当前点的孩子

            FindAroundPoint(i, pChild); //找到周围八个点Pchild

            //检查pChild是否能走 ( 是否是障碍物 或 已走过的点 或超过边界）
            if (map[pChild->pos.x][pChild->pos.y] == 0 &&
                pathMap[pChild->pos.x][pChild->pos.y] == false)
            {
                if (k != 0)  //第一次第一个搜索不拦截
                {
                    tmp2 = buff.begin();
                    for (; tmp2 != buff.end(); tmp2++)
                    {
                        tmp3 = *tmp2;
                        if (pChild->pos.x == tmp3->pos.x && pChild->pos.y == tmp3->pos.y)  //如果搜索的，在buff里已经存在了，拦下来
                        {
                            k = 2;
                            delete pChild;
                        }
                    }
                }

                if (k != 2)
                {
                    //计算h值
                    pChild->pos.h = getH(pChild->pos, endPos);

                    //计算f值
                    pChild->pos.f = pChild->pos.g + pChild->pos.h;

                    //入树
                    pCurrent->child.push_back(pChild);   //老节点把新节点包括在内，新节点成为老节点孩子
                    pChild->pParent = pCurrent;          //老节点成为新节点的父亲

                    //入容器
                    buff.push_back(pChild);              //可走的路都进来了，然后再选取最小，走了就把最小的删去   
                }
                k = 1;
            }
            else
            {
                delete pChild;  //不能走，释放pChild
            }
        }

        int buffSize = buff.size();
        printf("buffSize = %d ", buffSize);   

        //数组中挑出 f 最小的点
        //假设a最小，循环让b、c、d、e来跟a比较，如果c最小，让itMin等于c
        it = buff.begin();
        itMin = buff.begin();

        for (; it != buff.end(); it++)
        {
            itMin = ((*itMin)->pos.f < (*it)->pos.f) ? itMin : it;
        }

        //走
        pCurrent = *itMin;
        pathMap[pCurrent->pos.x][pCurrent->pos.y] = true;      //标记走过的点
        map[pCurrent->pos.x][pCurrent->pos.y] = 2;             //走过的路=2

        printf("\n");
        print3(map, ROWS, COLS, begPos, endPos, pCurrent);     //可视化
        printf("走了%d次\n", o);
        o++;
 
        Sleep(50);
        system("cls");
        
        //遇到终点或走完地图没终点，结束
        if (endPos.x == pCurrent->pos.x && endPos.y == pCurrent->pos.y)
        {
            isFindEnd = true;
            break;
        }
        if (buff.size() == 0)
        {
            break;
        }

        buff.erase(itMin);  //删掉走过的点，不然会拿到下一次做比较,遇到死胡同会回路，先判断完再删掉，不然只有一个走了后删了，就没了
    }

    IsFindEnd(isFindEnd, map, begPos, endPos, pCurrent);

    return 0;
}

bluuueY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
A星寻路算法&B星寻路算法 c++实现 MFC
11-26
AStar_Direct可能是指一种优化或变体的A星算法，可能是直接应用启发式函数而无需扩展中间节点，或者是在特定条件下减少搜索空间的策略。 B星算法（BStar）是A星算法的一个改进版本，它在处理动态环境或有大量可变...
AStar 算法实例
07-18
A星算法 对于空地左键单击后会产生障碍，对障碍左键单击会消除障碍，对于起点，两次左键盘单击会消除起点，如果不存在起点，单击右键会产生起点，如果存在起点不存在终点，单击右键会产生终点，如果既存在起点又存在...
A星(AStar)算法的实现
a1053904672的博客
08-15 6175
关于AStar的原理这里简述一下， 首先有一张地图，然后准备一个open list 和 close list，open list存放所有可能的路径，但是需要注意的是这个列表是动态怎加的，也就是每走一步就把当前可能的路径都加进去，然后每次从open list中去除一个最小代价的点，最为下一步的路径，并用该点计算之后可能的路径 在加入到open list中去，然后把这个代价最小的点放到close list中，表示该点已经走过了，如此循环直到从open list取出的最小代价点为 终点，此时通过回溯找到路径；代
Astar算法笔记
maruncheng的博客
09-30 959
A*算法最初发表于1968年，由Stanford研究院的Peter Hart, Nils Nilsson以及Bertram Raphael发表。它可以被认为是Dijkstra算法的扩展。A*算法属于启发式搜索(Heuristically Search)。
AStar算法优化
weixin_46034566的博客
01-12 3247
A星算法其实并不是最短路径算法，它找到的路径并不是最短的，它的目标首先是能以最快的速度找到通往目的地的路 A星算法也有很多弊端,就比如如果目的地不能到达 他还是会遍历寻路(可以寻路的时候判断 也可以算的上优化) 其次,如果地图过大,计算起来会很消耗时间,所以可以在计算上进行优化 下面说一下优化的一些可行的方法 一.距离过长时 距离很大，中间有很多障碍物时，A星的算法就会遇到瓶颈，不断加入的可行走点...
使用Astar（A星）算法解决八数码问题（Python代码）
weixin_52869970的博客
10-11 4962
Astar算法本质上是一种图搜索算法。图搜索算法就是将问题空间看作一个有向图空间，这个图空间由一个个图节点构成，问题的求解就转化为在问题空间中从初始节点出发，寻找一条通向目标节点的路径。在八数码问题中，棋局的每一个不同的状态都是一个节点，节点之间的转换是通过移动空格实现的。这样，通过选定初始节点和确定图转换规则（本问题中就是移动空格），我们就可以生成一个状态图，如：既然问题已经转化为图搜索问题了，那么我们可以确定一下搜索策略了。
自动驾驶路径规划——A*（Astar）算法
sinat_52032317的博客
10-03 2万+
      1968年发明的A*算法就是把启发式方法（heuristic approaches）如BFS，和常规方法如Dijsktra算法结合在一起的算法。      A-Star算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。
AStar算法
热门推荐
梦回唐朝
09-01 2万+
什么是AStar: 是一种静态路网中求解最短路最有效的直接搜索方法,估价值跟实例值非常接近; 启发式搜索 : 启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,在从这个位置进行搜索直到目标.这样可以省略大量无谓的搜索路径,提高了效率; 在启发式搜索中,对位置的估价是十分重要的.采用了不同的估价,可以有不同的效果; (估价函数就一种规则,制定的规则不同,...
Matlab算法代码 A星算法 路径规划A＊ Astar算法仿真
2301_76765778的博客
03-01 557
③路径平滑处理（引入梯度下降算法配合S-G滤波器）传统A＊+改进后的A*算法 Matlab代码。②冗余拐角优化（可显示拐角优化次数）路径规划A＊ Astar算法仿真。Matlab算法代码 A星算法。①提升搜索效率（引入权重系数）
A星寻路算法
weixin_43735634的博客
01-02 4608
通过该节点访问其上右下左的四个点，并判断这些点是否能够加入开放表（坐标超出网格范围，节点在关闭表，节点是障碍点。最后判断坐标点是否在开放表，不在开放表的点构建节点并加入开放表，这里默认两点间的代价为1；A星算法结合了广度优先搜索（BFS）和最佳优先搜索（Best-First Search）的特点，通过使用启发式函数评估节点的重要性，优先选择最有希望达到目标节点的节点进行扩展，从而有效地缩小搜索范围。public int CompareTo(AstarNode other) //排序方式。
A star算法
chunchun2021的博客
08-11 3510
A star是一种启发式算法，用于在图像中或者网格中寻找从起点到终点的最短路径，以下是A star算法的流程。
c++游戏开发 AStar A星寻路算法.zip
01-23
A星算法的核心思想是使用一个启发式函数来评估每个节点到目标节点的预计代价，这个函数通常是曼哈顿距离或欧几里得距离。算法过程中会维护一个优先队列，存储待处理的节点，并按照它们的f值（g值，即从起点到当前...
unicode_astar.rar_AStar_A星算法_A算法_astar matlab_a星算法 matlab
09-14
A星算法的核心在于引入了启发式函数（Heuristic Function），通常表示为h(n)，它是从当前节点n到目标节点的估计代价。启发式函数需要满足以下两个条件：一是非负性，即h(n) >= 0；二是 admissibility（可接纳性），...
astar:a星寻路算法javascript的实现
07-24
astar 最近更新 新增了JPS（跳点寻路），欢迎大家提issue 新增了TS版本，进一步的优化代码，以及进一步的简化用法，欢迎大家提issue 商业项目放心使用，有问题会及时更新！ 最近要用到寻路算法，偷懒网上搜了一批，...
算法-KMP字符串匹配
xx_xb的博客
07-23 191
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 679
AtCoder Beginner Contest 363 ABCDE
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 248
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 832
二叉搜索树向左或向右指明方向，不用遍历整个树。
a星算法MATLAB
06-13
A*（A star）算法是一种启发式搜索算法，常用于寻找从起点到目标的最短路径或最优解，特别是在图形（如地图）中。在MATLAB中，你可以使用内置的图搜索工具箱或者自定义实现来应用A*算法。 A*算法的关键在于两个组成...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值