A*寻路算法c＋＋

最新推荐文章于 2020-08-18 16:06:23 发布
最新推荐文章于 2020-08-18 16:06:23 发布
阅读量477 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011574810/article/details/53420536
版权

//

//  Algorithm_A_Self.cpp

//  StudyTest

//

//  Created by metrics001 on 16/11/9.

//

//


#include "Algorithm_A_Self.hpp"

#define DIS  50

#define boardDIS  140

#define boardDIS2  260


static POSTION allPOSTION[25];

static const POINT* point_head;


static vector*> pointList;


void Algorithm_A_Self::init_path(Layer* layer)

{

    

    int data[5][5] = {

        {1,1,1,1,1},

        {1,1,1,0,1},

        {1,1,1,0,1},

        {1,0,0,1,1},

        {1,1,1,1,1}

    };

    int index = 0;

    int n =5;int m =5;

    for (int i =0;i

        for (int j =0;j

            allPOSTION[index].x = j;

            allPOSTION[index].y = i;

            allPOSTION[index].value = data[i][j];

            index++;

        }

    }

    for (int i = 0; i<</span>25; i++) {

        Sprite* spr = Sprite::create("CloseNormal.png");

        layer->addChild(spr);

        spr->setPosition(Vec2(boardDIS+allPOSTION[i].x*DIS,boardDIS2-allPOSTION[i].y*DIS));

        if (allPOSTION[i].value==0) {

            spr->setColor(Color3B(255,0,0));

        }

    }

    

}


int Algorithm_A_Self::get_length(POINT* cur)

{

    int length = 1;

    POINT* point = cur;

    while (point->m_last!=nullptr) {

        point = point->m_last;

        length++;

    }

    return length;

}



bool Algorithm_A_Self::check_pos_valid(POSTION pos)

{

    for (int i = 0; i<</span>25; i++) {

        if (pos.x == allPOSTION[i].x&&pos.y == allPOSTION[i].y) {

            if (allPOSTION[i].value==0) {

                return  false;

            }

            return true;

        }

    }

    return false;

}



void Algorithm_A_Self::handle_point(POINT* cur,POSTION pos,vector* nextList)

{

    

    POINT* point = check_bool_at_path(pos,point_head);

    if (point==nullptr) {

        POINT* pData = new POINT();

        pData->m_pos = pos;

        cur->m_next->push_back(pData);

        pData->m_last = cur;

        pData->m_length = get_length(pData);

        //新加的放入下次搜索列表中

        nextList->push_back(pData);

    }else

    {

        

        point->m_length = get_length(point);

        cur->m_length = get_length(cur);

        if (point->m_length >cur->m_length+1) {

            

            POINT* last = point->m_last;

            point->m_last = cur;

            cur->m_next->push_back(point);

            if (last==nullptr) {

                return;

            }

            

            vector<_POINT*>* next = last->m_next;

            int index = 0;

            for (auto iter = next->begin(); iter != next->end(); iter++) {

                

                if (*iter==point) {

                    next->erase(next->begin()+index);

                    break;

                }

                index++;

            }

        }

        

    }

    

}


vector* Algorithm_A_Self::updata_data_for_queue(vector* points)

{

    if(NULL == points )

        return nullptr;

    vector* nextList = new vector();

    

    for(int index = 0; index < points->size(); index ++){

        

        POINT* data = points->at(index);

        if ( data->m_open==false) {  //检测过了，有点远

            continue;

        }

        

        vector* pointList = new vector();

        data->m_next = pointList;

        if(check_pos_valid(POSTION(data->m_pos.x, data->m_pos.y - 1))){

            handle_point(data,POSTION(data->m_pos.x, data->m_pos.y - 1),nextList);

        }

        

        if(check_pos_valid(POSTION(data->m_pos.x -1, data->m_pos.y))){

            handle_point(data,POSTION(data->m_pos.x -1, data->m_pos.y),nextList);

        }

        

        if(check_pos_valid(POSTION(data->m_pos.x, data->m_pos.y + 1))){

            handle_point(data,POSTION(data->m_pos.x, data->m_pos.y + 1),nextList);

        }

        

        if(check_pos_valid(POSTION(data->m_pos.x + 1, data->m_pos.y))){

            handle_point(data,POSTION(data->m_pos.x + 1, data->m_pos.y),nextList);

        }

    }

//    points->clear();

//    delete points;

    return nextList;

}


POINT* Algorithm_A_Self::check_bool_at_path(POSTION pos,const POINT* head)

{

    const POINT* cur = head;

    if (cur->m_pos.x==pos.x&&cur->m_pos.y==pos.y) {

//        printf("已经存在了\n");

        return (POINT*)cur;

    }

    if (cur->m_next == nullptr || cur->m_next->size()==0) {

        return nullptr;

    }

    for (auto iter = cur->m_next->begin(); iter != cur->m_next->end(); iter++) {

        POINT* point =  check_bool_at_path(pos,*iter);

        if (point!=nullptr) {

             return point;

        }

    }

    return nullptr;

}


//    得到估算距离最近

POINT* Algorithm_A_Self::sort_most_nearest_neigh(vector* pointList,POSTION end)

{

    //排序优先查找最小的

    sort(pointList->begin(),pointList->end(),[=](POINT* p1,POINT* p2){

                int dis1 = abs(p1->m_pos.x - end.x)+ abs(p1->m_pos.y - end.y) + get_length(p1);

                int dis2 = abs(p2->m_pos.x - end.x)+ abs(p2->m_pos.y - end.y)+ get_length(p2);;

        

//        point->m_length = get_length(point);

//        cur->m_length = get_length(cur);

        

//        float dis1 = (float) sqrt((p1->m_pos.x - end.x) * (p1->m_pos.x - end.x)+ (p1->m_pos.y - end.y) *  (p1->m_pos.y - end.y));

//        float dis2 = (float) sqrt((p2->m_pos.x - end.x) * (p2->m_pos.x - end.x)+ (p2->m_pos.y - end.y) *  (p2->m_pos.y - end.y));

        if (dis1

            return true;

        }

        return false;

    });

    return pointList->at(0);

}

POINT* Algorithm_A_Self::check_path(POINT* point,POSTION end)

{

    

    vector* points = new vector();

    points->push_back(point);

    

    while (true) {

        if (points->size()==0) {

            printf("此路不通\n");

            return nullptr;

        }

        pointList.push_back(points);

        //    //排序下一级的点

        POINT* min = sort_most_nearest_neigh(points,end);

         //    //关闭远的点

        int dis1 = abs(min->m_pos.x - end.x)+ abs(min->m_pos.y - end.y) + get_length(min);

        for (int i = 0;isize(); i++) {

            POINT *point = points->at(i);

            int dis = abs(point->m_pos.x - end.x)+ abs(point->m_pos.y - end.y) + get_length(point);

            if (dis>dis1) {

                point->m_open=false;

                break;

            }

        }

        

        for (auto iter = points->begin(); iter != points->end(); iter++) {

            POINT* cur = *iter;

            if (cur->m_pos.x==end.x&&cur->m_pos.y==end.y) {

                printf("找到目标了\n");

                return cur;

            }

        }

    

        points = updata_data_for_queue(points);

        

        printf("count:%d\n",(int)points->size());

        

    }

    return nullptr;

    

    

//    POINT* cur = point;

//    if (cur->m_pos.x==end.x&&cur->m_pos.y==end.y) {

//        printf("找到目标了\n");

//        return cur;

//    }

//    vector* points = updata_data_for_queue(cur);

//    if (points->size()==0) {

//        

//        printf("此路不通\n");

//         printf("%d,%d,\n",cur->m_pos.x,cur->m_pos.y);

//        return nullptr;

//    }

//    

//    

//    //排序下一级的点

//   POINT* min = sort_most_nearest_neigh(points,end);

//    

//    for (auto iter = points->begin(); iter != points->end(); iter++) {

//        POINT* cur = *iter;

//        POINT* point =check_path(cur, end);

//        if (point!=nullptr) {

//            printf("找到目标了\n");

//            return point;

//        }

//    }

//    

  return check_path(min,end);

//    

//    POINT* reult = nullptr;

//    for (auto iter = cur->m_next->begin(); iter != cur->m_next->end(); iter++) {

//        POINT* _reult = check_path(*iter,end);

//        if (_reult!=nullptr) {

//             return _reult;

            reult =  _reult;

//        }

//    }

//    return reult;

}

void Algorithm_A_Self::find_path(POSTION begin,POSTION end,Layer* layer)

{


    POINT*head = new POINT();

    point_head = head;

    POINT*cur = head;

    cur->m_pos = begin;

    POINT* end_pint = check_path(cur,end);

    if (end_pint == nullptr) {

        printf("没有找到可行路径\n");

        return ;

    }

//    routePOSTION 即为路径

    POINT* point = end_pint;

    vector routePOSTION;

    routePOSTION.push_back(point->m_pos);

    while (point->m_last!=nullptr) {

        point = point->m_last;

        routePOSTION.push_back(point->m_pos);

    }

    

    int count = pointList.size();

    for (int i = 0; i

        vector* points = pointList.at(i);

        for (int j = 0; jsize();j++) {

            POINT* point = points->at(j);

            

            Sprite* spr = Sprite::create("ui_b_next.png");

            layer->addChild(spr,2);

            spr->setPosition(Vec2(boardDIS+point->m_pos.x*DIS,boardDIS2-point->m_pos.y*DIS));

            spr->setVisible(false);

            spr->runAction(Sequence::create(DelayTime::create(i*1),CallFunc::create([=](){spr->setVisible(true);}),nullptr));

            spr->setColor(Color3B(60,60,60));

            

            Size size = spr->getContentSize();

            auto label = Label::createWithTTF(__String::createWithFormat("%d",i)->getCString(),"fonts/Marker Felt.ttf", 12);

            label->setPosition(Vec2( size.width/2, size.height/2));

            spr->addChild(label);

            

        }

        

    }

    

//    int count = (int)routePOSTION.size();

//    for (int i = 0; i

//        Sprite* spr = Sprite::create("ui_b_next.png");

//        layer->addChild(spr,2);

//        spr->setPosition(Vec2(boardDIS+routePOSTION.at(count-1-i).x*DIS,boardDIS2-routePOSTION.at(count-1-i).y*DIS));

//        spr->setVisible(false);

//        spr->runAction(Sequence::create(DelayTime::create(i*1),CallFunc::create([=](){spr->setVisible(true);}),nullptr));

//    }

//    

    Sprite* spr = Sprite::create("ui_record.png");

    layer->addChild(spr,1);

    spr->setPosition(Vec2(boardDIS+end.x*DIS,boardDIS2-end.y*DIS));



}

蜗牛lxy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++完整实现地图寻路A星算法
The Coding World
05-15 2882
A星寻路算法的讲解有很多，这里不再论述，只给出实现程序。 AStar.h #pragma once #include <vector> #include <map> #include <queue> // 二维地图A*算法实现 const int OBLIQUE = 14; // 斜线移动权重为14 const int STEP = 10; struct Point { Point(int id, int reachable); ~Point(); v
A*算法的实现（c++优先队列）
a854500070的博客
09-14 3211
A*算法的理解 对于A*算法，网上已经有了很详尽的描述，这里不再重复，如果想去看的话，我看了很多博客，最后看到这个博客的时候成功实现了A*算法。 在我看来，A*算法的实质其实就是BFS，只不过BFS的过程中加入了一个变量f，每次选出f最小的点进行BFS，BFS决定了我们能找到最优解，变量f能让我们贪心的找到最优解。 struct node { int x, y; int f,
A星算法(游戏寻路算法)的C++实现
lightrain0的博客
11-22 1309
A星算法的实现原理看这里：http://www.cnblogs.com/technology/archive/2011/05/26/2058842.html       实现部分：     头文件：   [cpp] view plain copy   /*      A star 算法的基础处理  */   #ifndef _A_STAR_BASE_H_   #define ...
A*寻路算法C++简单实现
一抹烟霞的博客
11-02 624
搜索区域 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 如图所示简易地图, 其中绿色方块的是起点 (用 A 表示), 中间蓝色的是障碍物, 红色的方块 (用 B 表示) 是目的地. 为了可以用一个二维数组来表示地图, 我们将地图划分成一个个的小方块。 开始寻路 1.从起点A开始, 把它作为待...
A*算法、自动寻路算法C++源码
11-21
A*算法的C++实现，注释详尽，直接编译运行
a*寻路算法,c++类
03-07
**A*寻路算法**是一种广泛应用的路径搜索算法，它结合了Dijkstra算法的最短路径特性以及优先级队列的效率，同时引入了启发式信息以提高搜索速度。在游戏开发、图形图像处理、地图导航等领域，A*算法被广泛用于计算两...
a*寻路 c++实现
11-02
**a*寻路算法**是一种广泛应用的路径搜索算法，它结合了Dijkstra算法的最短路径特性与启发式搜索的效率。在C++中实现a*寻路算法，通常会用到数据结构如二叉堆（优先队列）来优化性能。在此项目中，八方向的移动模型...
A星寻路算法&B星寻路算法 c++实现 MFC
11-26
总之，这个项目提供了C++实现的A星和B星寻路算法，结合MFC创建了一个可视化环境，用户可以观察和比较不同算法的寻路效果。通过调试和优化，这些算法可以应用于各种需要寻找最短路径的问题中，比如游戏中的角色移动、...
A*搜索四方向寻路 C++代码实现
HfCloud的博客
02-16 3558
眼馋A*算法很久了，可是很久却还不能入门。昨天终于狠下心来，花一天使劲折腾它，终于写出了A*搜索，（我写的是自动寻路系统，很多网游里面用的那种)。我也在网上搜了很久。但一直没有找到c++的实现，于是就自己造了这个轮子。下面是几张运行的截图: 关于A*算法的理论原理，网上已经有很多文章介绍了，而我只是初学，理论不是特别清晰，所以也不在此献丑了。仅在此贴上代码
基于A*算法的游戏地图寻路实现及性能比较 (2011年)
05-07
在A*算法描述的基础上,给出了基于分层寻路思想的A*算法优化方法及划分游戏地图的6种方式.针对26×20=520个节点的游戏地图,利用栅格法按8方向连接对游戏地图进行了划分,分别采用Dijkstra算法、双向宽度优先搜索算法、A*(曼哈顿距离)算法、A*(欧氏距离)算法、A*(切比雪夫距离)算法和动态A*算法5种算法进行了寻路仿真实验,对比分析了各种寻路算法的性能.实验结果表明A*算法是各种寻路算法中扩展节点数量最少和计算耗时最短的一种算法;当采用不同的启发式函数,A*寻路时扩展的节点数量也不同,因此选择
A星算法自动寻路(C++源代码）
06-20
A星算法自动寻路(C++源代码），供大家学习使用
A*算法（C++实现）
热门推荐
A_L_A_N
08-03 3万+
简易地图 如图所示简易地图, 其中绿色方块的是起点 (用 A 表示), 中间蓝色的是障碍物, 红色的方块 (用 B 表示) 是目的地. 为了可以用一个二维数组来表示地图, 我们将地图划分成一个个的小方块. 二维数组在游戏中的应用是很多的, 比如贪吃蛇和俄罗斯方块基本原理就是移动方块而已. 而大型游戏的地图, 则是将各种"地貌"铺在这样的小方块上. 寻路步骤 1. 从起点A开始, 把它作...
C++实现A*寻路
weixin_43701019的博客
02-02 717
A*寻路原理可查看之前的文章:游戏AI中的寻路算法（A*算法） 上面的是C#，下面是用C++实现的Astart类（大致一样），main函数就要自己构造地图和随机： //Astart.h //路径的节点 struct Node { int x; //坐标 int y; int G; //从起点到当前位置的值 int H; //从当前位置到终点预...
不再依赖A*，利用C++编写全新寻路算法
xuela-net
07-02 266
一，说在前面的话 大概在半年前，看见一到信息竞赛题：在任意方格阵中设置障碍物，确定起始点后，求这两点之间路径。当时觉得蛮有意思的，但是没有时间去做，今天花了两个小时来实现它。据说有一个更高级的寻路算法叫做a*, 那我就把我的算法叫做W*。 这个算法主要用于解迷宫和实现战棋游戏(SLG)的寻路。 首先讲一讲我的算法的思路： 我们先确定起始点，然后从起点出发，按一定顺序判断这个位置上下左右是否...
《C++游戏开发》十七 游戏中的寻路算法(三)：A*算法原理
C++游戏开发
08-28 1万+
A*算法路径的评价公式为F=G+H 其中H为某个已达格子到目的地的估算距离，估算的方法有很多种，比如： 1、曼哈顿距离：即两点水平距离加上竖直距离。比如（x1,y1）到（x2,y2）的曼哈顿距离就是|x2-x1|+|y2-y1|。 2、欧式距离：即两点之间的真实距离。（x1，y1）到（x2，y2）的欧式距离就是 sqrt（（x2-x1）*（x2-x1）+（y2-y1）*（y2-y1））。 3、切比雪夫距离：水平方向和竖直方向上的距离最大
手把手教会用C++实现A*算法
weixin_43619346的博客
08-18 9173
书接上回，上一篇博客我们介绍了A算法最基本的原理，本篇博客我们来手把手的教会大家A算法的C++实现！原文链接在此，大佬分别用Python、C++、C#进行了算法的实现orz 正文如下： 本文是我对A *的介绍的辅助指南，在此我将解释算法的工作原理。 在此页面上，我将展示如何实现广度优先搜索，Dijkstra的算法，贪婪的最佳优先搜索和A *。 我尝试使代码保持简单。 图搜索有一系列相关算法。算法有很多变体，实现上也有很多变体。将本文展示的代码视为一个起点，而不是适用于所有情况的最终版本。 c++实现 注
用C++写一个A*寻路算法
最新发布
03-22
好的，以下是一个简单的C语言实现的A*寻路算法： ```c #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define ROW 5 #define COL 5 typedef struct { int x, y; } Point; typedef struct { Point parent; int f, g, h; } Node; Node map[ROW][COL]; Point start, end; bool is_valid(int x, int y) { return x >= 0 && x < ROW && y >= 0 && y < COL; } bool is_obstacle(int x, int y) { return map[x][y].f == -1; } int heuristic(int x, int y) { return abs(x - end.x) + abs(y - end.y); } void print_path() { Point path[ROW * COL]; int count = 0; Point current = end; while (current.x != start.x || current.y != start.y) { path[count++] = current; current = map[current.x][current.y].parent; } path[count++] = start; printf("Path: "); for (int i = count - 1; i >= 0; i--) { printf("(%d, %d) ", path[i].x, path[i].y); } printf("\n"); } void a_star() { int dx[8] = {-1, -1, 0, 1, 1, 1, 0, -1}; int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1}; map[start.x][start.y].f = 0; map[start.x][start.y].g = 0; map[start.x][start.y].h = heuristic(start.x, start.y); Node open_set[ROW * COL]; int open_set_size = 1; open_set[0] = map[start.x][start.y]; while (open_set_size > 0) { int current_index = 0; for (int i = 1; i < open_set_size; i++) { if (open_set[i].f < open_set[current_index].f) { current_index = i; } } Node current = open_set[current_index]; if (current.parent.x == end.x && current.parent.y == end.y) { print_path(); return; } open_set[current_index] = open_set[open_set_size - 1]; open_set_size--; for (int i = 0; i < 8; i++) { int new_x = current.parent.x + dx[i]; int new_y = current.parent.y + dy[i]; if (!is_valid(new_x, new_y) || is_obstacle(new_x, new_y)) { continue; } int new_g = current.g + 1; int new_h = heuristic(new_x, new_y); int new_f = new_g + new_h; if (map[new_x][new_y].f == -2 || new_f < map[new_x][new_y].f) { map[new_x][new_y].parent = current.parent; map[new_x][new_y].f = new_f; map[new_x][new_y].g = new_g; map[new_x][new_y].h = new_h; if (map[new_x][new_y].f == -2) { open_set[open_set_size++] = map[new_x][new_y]; } } } } printf("No path found!\n"); } int main() { // initialize map for (int i = 0; i < ROW; i++) { for (int j = 0; j < COL; j++) { map[i][j].parent.x = i; map[i][j].parent.y = j; map[i][j].f = -2; map[i][j].g = -2; map[i][j].h = -2; } } // set obstacles map[1][1].f = -1; map[1][2].f = -1; map[1][3].f = -1; map[2][3].f = -1; map[3][3].f = -1; map[3][2].f = -1; // set start and end points start.x = 0; start.y = 0; end.x = 4; end.y = 4; // run A* algorithm a_star(); return 0; } ``` 这个程序实现了一个简单的A*寻路算法，可以在一个5x5的地图上找到从起点到终点的最短路径。其中，-1表示障碍物，-2表示未访问过的节点，其它数字表示已访问过的节点的f值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值