一个高效的A-star寻路算法（八方向）(

最新推荐文章于 2024-03-10 22:09:24 发布
最新推荐文章于 2024-03-10 22:09:24 发布
阅读量8.8k 收藏 5
点赞数 2
分类专栏： c# java
c# 同时被 2 个专栏收录
43 篇文章 0 订阅
订阅专栏
java
21 篇文章 0 订阅
订阅专栏

 

这种写法比较垃圾，表现在每次搜索一个点要遍历整个地图那么大的数组，如果地图为256*256，每次搜索都要执行65535次，如果遍历多个点就是n*65535，速度上实在是太垃圾了

简单说下思路，以后补充算法

优化重点在在open表和close表的遍历上，这两个地方优化后，astar会大量提速

close只用来查询所以可以用hash这样就避免了遍历

open首先用来查询是否有相同的点如果有会比较替换F值，其次用来遍历查询最小点，如果用优先级队列加hash可以减少2次遍历，但是相同点替换F值和父节点就没办法了，只能遍历一次（但一般找到该找的点就可以break，不需要完整遍历）

如果用java，c#，由于有垃圾回收机制，为了避免产生过多垃圾降低垃圾回收压力，可以用空闲对象池来避免频繁创建节点，控制内存泄露

 

 

 

原作者是http://www.codefans.net的JAROD

之所以说这个A-star算法高效，是因为它的open-list和close-list使用的完全是静态数组，这样就极大地降低了入栈出栈的负担。这个代码非常值得推荐。

用法很简单：
route_pt[] result = null;
// result_pt是一个简单类，它只有两个成员变量：int x和int y。
// 参数说明：map是一个二维数组，具体见程序注释
AStarRoute2 asr = new AStarRoute2(map, start_x, start_y, end_x, end_y);
try {
    result = asr.getResult();
}catch (Exception ex) {
}
如果result != null那么寻路就成功了。
注意：最后获得的路径，是从终点指向起点的。您可以把两组参数倒过来传，以获得正常方向的返回值。

本人对JAROD的代码略作修改，主要是用循环取代了递归，避免栈溢出。
这是本人修改后的八方向寻路算法。如下：

import java.util.ArrayList;

public class AStarRoute2 {
    private int[][] map;  // 地图矩阵，0表示能通过，1表示不能通过
    private int map_w;    // 地图宽度
    private int map_h;    // 地图高度
    private int start_x;  // 起点坐标X
    private int start_y;  // 起点坐标Y
    private int goal_x;   // 终点坐标X
    private int goal_y;   // 终点坐标Y

    private boolean closeList[][];            // 关闭列表
    public  int openList[][][];               // 打开列表
    private int openListLength;

    private static final int EXIST = 1;
    private static final int NOT_EXIST = 0;

    private static final int ISEXIST = 0;  
    private static final int EXPENSE = 1;     // 自身的代价
    private static final int DISTANCE = 2;    // 距离的代价
    private static final int COST = 3;        // 消耗的总代价
    private static final int FATHER_DIR = 4;  // 父节点的方向

    public static final int DIR_NULL = 0;
    public static final int DIR_DOWN = 1;     // 方向：下
    public static final int DIR_UP = 2;       // 方向：上
    public static final int DIR_LEFT = 3;     // 方向：左
    public static final int DIR_RIGHT = 4;    // 方向：右
    public static final int DIR_UP_LEFT = 5;
    public static final int DIR_UP_RIGHT = 6;
    public static final int DIR_DOWN_LEFT = 7;
    public static final int DIR_DOWN_RIGHT = 8;

    private int astar_counter;                // 算法嵌套深度
    private boolean isFound;                  // 是否找到路径

    public AStarRoute2(int[][] mx, int sx, int sy, int gx, int gy){
        start_x = sx;
        start_y = sy;
        goal_x  = gx;
        goal_y  = gy;
        map     = mx;
        map_w   = mx.length;
        map_h   = mx[0].length;
        astar_counter = 5000;
        initCloseList();
        initOpenList(goal_x, goal_y);
    }

    // 得到地图上这一点的消耗值
    private int getMapExpense(int x, int y, int dir)
    {
        if(dir < 5){
            return 10;
        }else{
            return 14;
        }
    }

    // 得到距离的消耗值
    private int getDistance(int x, int y, int ex, int ey)
    {
        return 10 * (Math.abs(x - ex) + Math.abs(y - ey));
    }

    // 得到给定坐标格子此时的总消耗值
    private int getCost(int x, int y)
    {
        return openList[x][y][COST];
    }

    // 开始寻路
    public void searchPath()
    {
        addOpenList(start_x, start_y);
        aStar(start_x, start_y);
    }

    // 寻路
    private void aStar(int x, int y)
    {
        // 控制算法深度
        for(int t = 0; t < astar_counter; t++){
            if(((x == goal_x) && (y == goal_y))){
                isFound = true;
                return;
            }
            else if((openListLength == 0)){
                isFound = false;
                return;
            }

            removeOpenList(x, y);
            addCloseList(x, y);

            // 该点周围能够行走的点
            addNewOpenList(x, y, x, y + 1, DIR_UP);
            addNewOpenList(x, y, x, y - 1, DIR_DOWN);
            addNewOpenList(x, y, x - 1, y, DIR_RIGHT);
            addNewOpenList(x, y, x + 1, y, DIR_LEFT);
            addNewOpenList(x, y, x + 1, y + 1, DIR_UP_LEFT);
            addNewOpenList(x, y, x - 1, y + 1, DIR_UP_RIGHT);
            addNewOpenList(x, y, x + 1, y - 1, DIR_DOWN_LEFT);
            addNewOpenList(x, y, x - 1, y - 1, DIR_DOWN_RIGHT);

            // 找到估值最小的点，进行下一轮算法
            int cost = 0x7fffffff;
            for(int i = 0; i < map_w; i++){
                for(int j = 0; j < map_h; j++){
                    if(openList[i][j][ISEXIST] == EXIST){
                        if(cost > getCost(i, j)){
                            cost = getCost(i, j);
                            x = i;
                            y = j;
                        }
                    }
                }
            }
        }
        // 算法超深
        isFound = false;
        return;
    }

    // 添加一个新的节点
    private void addNewOpenList(int x, int y, int newX, int newY, int dir)
    {
        if(isCanPass(newX, newY)){
            if(openList[newX][newY][ISEXIST] == EXIST){
                if(openList[x][y][EXPENSE] + getMapExpense(newX, newY, dir) < 
                    openList[newX][newY][EXPENSE]){
                    setFatherDir(newX, newY, dir);
                    setCost(newX, newY, x, y, dir);
                }
            }else{
                addOpenList(newX, newY);
                setFatherDir(newX, newY, dir);
                setCost(newX, newY, x, y, dir);
            }
        }
    }

    // 设置消耗值
    private void setCost(int x, int y, int ex, int ey, int dir)
    {
        openList[x][y][EXPENSE] = openList[ex][ey][EXPENSE]  + getMapExpense(x, y, dir);
        openList[x][y][DISTANCE] = getDistance(x, y, ex, ey);
        openList[x][y][COST] = openList[x][y][EXPENSE]  + openList[x][y][DISTANCE];
    }

    // 设置父节点方向
    private void setFatherDir(int x, int y, int dir)
    {
        openList[x][y][FATHER_DIR] = dir;
    }

    // 判断一个点是否可以通过
    private boolean isCanPass(int x, int y)
    {
        // 超出边界
        if(x < 0 || x >= map_w || y < 0 || y >= map_h){
            return false;
        }
        // 地图不通
        if(map[x][y] != 0){
            return false;
        }
        // 在关闭列表中
        if(isInCloseList(x, y)){
            return false;
        }
        return true;
    }

    // 移除打开列表的一个元素
    private void removeOpenList(int x, int y)
    {
        if(openList[x][y][ISEXIST] == EXIST){
            openList[x][y][ISEXIST] = NOT_EXIST;
            openListLength--;
        }
    }

    // 判断一点是否在关闭列表中
    private boolean isInCloseList(int x, int y)
    {
        return closeList[x][y];
    }

    // 添加关闭列表
    private void addCloseList(int x, int y)
    {
        closeList[x][y] = true;
    }

    // 添加打开列表
    private void addOpenList(int x, int y)
    {
        if(openList[x][y][ISEXIST] == NOT_EXIST){
            openList[x][y][ISEXIST] = EXIST;
            openListLength++;
        }
    }

    // 初始化关闭列表
    private void initCloseList()
    {
        closeList = new boolean[map_w][map_h];
        for(int i = 0; i < map_w; i++){
            for(int j = 0; j < map_h; j++){
                closeList[i][j] = false;
            }
        }
    }

    // 初始化打开列表
    private void initOpenList(int ex, int ey)
    {
        openList  = new int[map_w][map_h][5];
        for(int i = 0; i < map_w; i++){
            for(int j = 0; j < map_h; j++){
                openList[i][j][ISEXIST] = NOT_EXIST;
                openList[i][j][EXPENSE] = getMapExpense(i, j, DIR_NULL);
                openList[i][j][DISTANCE] = getDistance(i, j, ex, ey);
                openList[i][j][COST] = openList[i][j][EXPENSE]  + openList[i][j][DISTANCE];
                openList[i][j][FATHER_DIR] = DIR_NULL;
            }
        }
        openListLength = 0;
    }

    // 获得寻路结果
    public route_pt[] getResult(){
        route_pt[] result;
        ArrayList<route_pt> route;
        searchPath();
        if(! isFound){
            return null;
        }
        route = new ArrayList<route_pt>();
        // openList是从目标点向起始点倒推的。
        int iX = goal_x;
        int iY = goal_y;
        while((iX != start_x || iY != start_y)){
            route.add(new route_pt(iX, iY));
            switch(openList[iX][iY][FATHER_DIR]){
            case DIR_DOWN:          iY++;            break;
            case DIR_UP:            iY--;            break;
            case DIR_LEFT:          iX--;            break;
            case DIR_RIGHT:         iX++;            break;
            case DIR_UP_LEFT:       iX--;   iY--;    break;
            case DIR_UP_RIGHT:      iX++;   iY--;    break;
            case DIR_DOWN_LEFT:     iX--;   iY++;    break;
            case DIR_DOWN_RIGHT:    iX++;   iY++;    break;
            }
        }
        int size = route.size();
        result = new route_pt[size];
        for(int i = 0; i < size; i++){
            result[i] = new route_pt((route_pt)route.get(i));
        }
        return result;
    }
}
000000000000O
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【原创】Flex中A-star寻路算法
07-27
NULL 博文链接：https://qiqishou.iteye.com/blog/756690
A*算法的C#实现
weixin_34240520的博客
10-22 182
     在游戏开发中，AI的最基本问题之一就是寻路算法或称路径规划算法，在三年前，我曾实现过基于“图算法”的最短路径规划算法，然而在游戏中，我们通常将地图抽象为有单元格构成的矩形，如：           （本图源于这里）      这个微型地图由3*3的单元格构成，当然，实际游戏中的地图通常比它大很多，这里只是给出一个示例。      由于游戏地图通常由单元格构成，所以，基于“图算法”的...
常见寻路算法基本思路汇总
最新发布
weixin_51956624的博客
03-10 642
一、迪杰斯特拉(Dijkstra)算法是典型最短路径算法，基于广度优先算法BFS进行改进，用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先遍历思想)，直到扩展到终点为止以上图为例，来对迪杰斯特拉进行算法演示(以顶点D为起点)。
代码 A-Star A星算法，适合塔防游戏、自动寻路
05-14
代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-Star A星算法，适合塔防游戏、自动寻路代码 A-S
AStarpathfinder.rar_A star 算法_A算法 地图_a-star_寻路_寻路算法
09-22
简单的A-star寻路算法，给出了几种不同的地图，并得到正确的寻路结果
C#实现的b-star寻路算法
07-03
c#实现的b-star算法， 讲解和详情见博客： https://blog.csdn.net/Koweico/article/details/107114537
自动驾驶路径规划——A*（Astar）算法
sinat_52032317的博客
10-03 1万+
      1968年发明的A*算法就是把启发式方法（heuristic approaches）如BFS，和常规方法如Dijsktra算法结合在一起的算法。      A-Star算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。
AStar寻路算法
weixin_46084262的博客
12-19 3931
AStar算法是一种图形搜索算法，常用于寻路。他是以广度优先搜索为基础，集Dijkstra算法和最佳优先(best fit)于一身的一种算法。
AStar(A*) 算法
lq
12-28 3186
A*算法是一种静态网格中求解最短路径最有效最直接的搜索方法，估计值与实际值越接近，估价函数取得就越好。 除了A*算法还有很多其他算法，当然有很多寻路算法比A*算法寻路快很多倍，在此主要说A*算法，其他算法不做过多介绍。 A*算法公式为 ： f ( n ) = g ( n ) + h ( n ). 其中 f(n) 是从初始点经由节点n到目标点的估价函数， g(n) 是在状态空间中从初始节...
Astar算法
鱼儿往上游的博客
11-02 8339
1.什么是Astar算法？ Astar算法是一种图形搜索算法，常用于寻路。它是个以广度优先搜索为基础，集Dijkstra算法与最佳优先(best fit)算法特点于一身的一种算法。 它通过下面这个函数来计算每个节点的优先级，然后选择优先级最高的节点作为下一个待遍历的节点。优先级函数： 其中： 1.g(n) 是节点n距离起点的代价。 2.h(n)是节点距离终点的预计代价，也就是A*算法的启发函数。 A*算法伪代码如下： //使用open_set、close_set来表示待遍
基于英雄联盟寻路背景的A星算法及python实现
zaowuyingshu的博客
03-27 1601
文章目录前言一、什么是A星算法？二、算法流程三、python算法实现四、结果展示 前言 Astar算法是游戏中最常见的寻路算法，比如LOL的自动导航等。 一、什么是A星算法？ Astar算法是在实际生活和工业应用包括游戏设计等情景中所频繁被使用的一种路径规划算法。算法类似于贪婪最佳优先搜索，因为同样属于启发式算法，通过设定一个估价函数来实现。标准算法计算当前位置上相邻的每个节点，其方向可以是四面也可以是八面，并选择估价函数值成本最低的节点加入数组。添加到新数组的节点将用于搜索更多可行的路径。A*搜索算.
A_Star_ Algol-A算法_寻路_A_Star算法_
10-01
A星最短寻路算法
C# Astar算法
Chobits的专栏
07-30 1039
http://firechun.blog.163.com/blog/static/31804522200961132413534/
AI自动寻路AStar算法【图示讲解原理】
Jacksqh的博客
04-09 5323
本文通过图示讲解了AI自动寻路算法中AStar算法的实现原理，读完相信对您会有所帮助
C#开发WPF/Silverlight动画及游戏系列教程(Game Tutorial)：(十九) 完美精灵之八面玲珑(WPF Only)③...
weixin_34085658的博客
06-27 59
       首先我要对上一节中最后的ChangeAction()方法进行一些补充说明。该方法的作用之一是根据精灵的当前动作(Action)来设置精灵切图动画的起始帧和结束帧：        如上图，我们可以很清楚的看到精灵这5个动作所分别对应的CurrentStartFrame和CurrentEndFrame。这两个参数很重要是因为在精灵的生命线程中我们可以通过如下黄色区域代码来实现动态的...
在Unity中实现Astar寻路算法
Meytones的博客
02-19 2315
在游戏中，从一点到另一点的操作有时需要游戏系统自动完成，在一些带有rpg元素的游戏中，敌人在发现玩家位置后会自动向玩家的位置移动。这些移动的路线是如何自动确定的？本文将介绍寻路算法中的A*算法，并在unity中用C#脚本来实现寻路功能。
AStar算法
热门推荐
梦回唐朝
09-01 2万+
什么是AStar: 是一种静态路网中求解最短路最有效的直接搜索方法,估价值跟实例值非常接近; 启发式搜索 : 启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,在从这个位置进行搜索直到目标.这样可以省略大量无谓的搜索路径,提高了效率; 在启发式搜索中,对位置的估价是十分重要的.采用了不同的估价,可以有不同的效果; (估价函数就一种规则,制定的规则不同,...
AStar算法优化
weixin_46034566的博客
01-12 3153
A星算法其实并不是最短路径算法，它找到的路径并不是最短的，它的目标首先是能以最快的速度找到通往目的地的路 A星算法也有很多弊端,就比如如果目的地不能到达 他还是会遍历寻路(可以寻路的时候判断 也可以算的上优化) 其次,如果地图过大,计算起来会很消耗时间,所以可以在计算上进行优化 下面说一下优化的一些可行的方法 一.距离过长时 距离很大，中间有很多障碍物时，A星的算法就会遇到瓶颈，不断加入的可行走点...
c#实现的b-star寻路算法
07-18
c的形状类似于一个半圆，上面有一条短直线。在印刷体字母中，c的形状更加圆滑。 c在拼音中代表着不同的音素，它可以和其他字母组合成不同的音。例如，在英语中，c与a、o、u等元音字母结合，可以发/k/的音。比如cat...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值