一个高效的A-star寻路算法(四方向)

算法学习记录——简单的 A*寻路实现——>四个方向(JAVA实现) A*寻路算法——一种寻找从起点A到终点B的有效路径的算法,游戏设计中的角色移动经常会采用这种算法来实现。 说明:由于是初学者,对算法的理解还不够透彻,下面的分析过程,只考虑最简单的情况——平面四个方向(上,下,左,右)的搜索。 下图中的 S 代表起点(start), E 代表终点(E),中间有填充色的区域为 障碍 ——不可穿过,需绕行。 ... 阅读详情

原帖:http://blog.sina.com.cn/s/blog_53a5865c0102dycg.html

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

用法很简单:
route_pt[] result = null;
// result_pt是一个简单类,它只有两个成员变量:int x和int y。
// 参数说明:map是一个二维数组,具体见程序注释
// start_x,start_y:起点坐标;end_x,end_y:终点坐标。
AStarRoute asr = new AStarRoute(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 AStarRoute {
    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;    // 方向:右

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

    public AStarRoute(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)
    {
        return 1;
    }

    // 得到距离的消耗值
    private int getDistance(int x, int y, int ex, int ey)
    {
        return (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);

            // 找到估值最小的点,进行下一轮算法
            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) <
                    openList[newX][newY][EXPENSE]){
                    setFatherDir(newX, newY, dir);
                    setCost(newX, newY, x, y);
                }
            }else{
                addOpenList(newX, newY);
                setFatherDir(newX, newY, dir);
                setCost(newX, newY, x, y);
            }
        }
    }

    // 设置消耗值
    private void setCost(int x, int y, int ex, int ey)
    {
        openList[x][y][EXPENSE] = openList[ex][ey][EXPENSE] + getMapExpense(x, y);
        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);
                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;
            }
        }
        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;
    }
}

(完)


 

我测试了一下,发现map_w和map_h的值写反了

初始化的时候应该是:

map_w  = mx.length;
map_h  = mx[0].length;
博主回复:2012-10-24 08:20:04
谢谢!我的地图凑巧是一个正方形,有时间我再测一下。


 

你的这个算法貌似递归没有啊。addNewOpenList()。
博主回复:2012-11-29 15:59:11
用递归容易导致栈溢出。我特意将递归展算法开为循环算法。


 

Java随机Prim算法和A*算法生成随机迷宫 程序功能: 1,随机Prim算法生成迷宫地图 游戏中需要随机生成迷宫地图,引入java.util.Random类,利用Random类提供的生成随机数方法,随机生成障碍物、通路或者奖励等状态。迷宫地图采用二维数组进行表示与存储。 2,A*算法求解迷宫路径 根据A*算法求解出当前位置迷宫的路径 3,判断玩家闯关是否成功 根据玩家的当前位置是否位于地图的出口点来判断玩家闯关是否成功。 4,游戏主控模块 输入“←↑↓→”则根据是否能进行移动来更新游戏界面和当前位置,已经退出,难度更改,路径显示等功能 阅读详情

相关推荐

A Star算法原理及其实现

A -Star算法 A*(A-Star)算法是一种求解最短路径最有效的直接搜索方法,也是许多其他问题的常用启发式算法。 一、简介 二、寻路方式 三、运行机制 四、常用估价算法 五、示例 一、简介 A*(A-Star)算法是一种求解最短路径最有效的直接搜索方法,也是许多其他问题的常用启发式算法。注意——是最有效的直接搜索算法,之后涌现了很多预处理算法(如ALT,CH,HL等等),在线查询效率是A*算法的数千甚至上万倍。 公式表示为: f(n)=g(n)+h(n), 其中, f(n) ..

大隐隐于野 9598

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

原帖:http://blog.sina.com.cn/s/blog_53a5865c0102dycw.html 原作者是http://www.codefans.net的JAROD 之所以说这个A-star算法高效,是因为它的open-list和close-list使用的完全是静态数组,这样就极大地降低了入栈出栈的负担。这个代码非常值得推荐。 用法很简单: route_pt[] resu

Android For Java 3787

A_star/ A*算法解决自动寻路问题

在许多游戏中,以及地图导航、路线规划等领域,自动寻路算法扮演着至关重要的角色。这些算法的目标是根据起点和终点之间的地形、障碍物和其他限制条件,找到一条最优或可行的路径。游戏中的NPC行动:自动寻路算法用于游戏中的非玩家角色(NPC),使其能够智能地避开障碍物、追踪目标或规避敌人;策略游戏的路径规划:在策略游戏中,自动寻路算法用于计算最佳的行军路径、资源收集路径或建筑物布局;实时导航系统:自动寻路算法用于实时导航系统,帮助用户找到最短或最优的路径,以避开交通拥堵或规避其他限制条件.地形和障碍物处理。

qq_62617798的博客 1893

A*算法(一):4方向

介绍与准备 A算法是一种用于方格地图寻找最短路径的算法,这种算法适用于静态地图。本篇文章讲述A算法的最简版本,也就是只考虑四个方向的A*算法。所谓的四个方向就是指可以上下左右移动,但不允许斜着移动。 方格内有A,B,C三个变量。 A指初始位置到当前方格的最小代价 B指当前方格到终点的估计代价 C指A + B的值 例如下图,橙色方块A = 1,B = 5,C = 1 + 5 = 6。B所谓的估计代价就是当前方块与终点的横向差值(绝对值)和纵向差值(绝对值)的和。对于橙色方块而言横向差值为3,纵向差值为2,所

PYJTLK的博客 2436

MaxEnt软件的下载与安装

1、下载网站:http://lucky-boy.ys168.com/ (这是之前在网上搜到的,里面有许多软件安装包,感谢网页主的资源共享,违权必删)

weixin_42191203的博客 2万+

MatLab:数字图像处理实验

图像处理基本处理实验目的实验环境实验内容题目一代码结果题目二平移平移代码平移结果水平镜像水平镜像代码水平镜像结果垂直镜像垂直镜像代码垂直镜像结果放大放大代码放大结果缩小缩小代码缩小结果旋转旋转代码旋转结果双线性旋转旋转代码旋转结果 实验目的 1、熟悉并掌握MATLAB工具的使用;  2、实现图像的读取、显示、存储、平移、镜像、放大、缩小及旋转操作; 3、掌握常用的插值方法,并了解其优缺点。 实验环境 MatLab2016 实验内容 题目一 读入一幅RGB图像,变换为灰度图像和二值图像,并在同一个窗口内分别显

luoyao_的博客 9697

A*自动寻路算法—java版

前段时间一直在写一个小游戏,需要用到自动寻路,于是就百度了一番,终于完成了,现在将原理及代码展示出来,方便有兴趣的朋友参考。说明一下,本次只展示了上下左右四个方向的移动。如图:如果从A点走到B点,有很多条路线,如何自动找到路线,以及如何找到最短的路线,就是这次要解决的问题。首先,需要讲解一下计算的公式,F=G+H,主要用于判断最佳路线。G:(左上角数值)起点到当前点的消耗(即步数),比如C点,与A...

newbie的博客 8496

基于MediaPipe的智能俯卧撑计数与姿势矫正系统

在现代健身和体能训练中,俯卧撑是最基础也是最有效的自重训练动作之一。然而,许多人在进行俯卧撑训练时常常存在姿势不正确、计数不准确等问题。本文将介绍如何利用计算机视觉和姿态估计技术,开发一个智能的俯卧撑计数与姿势矫正系统。

qq_36224726的博客 918

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

这种写法比较垃圾,表现在每次搜索一个点要遍历整个地图那么大的数组,如果地图为256*256,每次搜索都要执行65535次,如果遍历多个点就是n*65535,速度上实在是太垃圾了 简单说下思路,以后补充算法 优化重点在在open表和close表的遍历上,这两个地方优化后,astar会大量提速 close只用来查询所以可以用hash这样就避免了遍历 ...

aikb6223的博客 1256

spm FMRI 各种小问题合集

预处理 1、预处理结果从normalize之后开始头歪、变形 问题描述:如下图 原因:DICOM2NIfTI时必须检查对应的T1像。下面是两种错误形式,第一种容易发现,第二种容易忽视,大脑失状位左右颠倒。 解决:重新转了一回格式,建议用SPM fmri进行格式转换。之前是用MRIconvert转换的,用了两台电脑,有的T1结果是对的,不确定什么原因产生的错位,操作都是一样的。 2、Check reg大脑图片边缘出边框 问题描述: 原因:应该是图片排版导致的,单独check就会发现大脑是全的。 解决

weixin_44669441的博客 1677

PLCopen运动控制避坑指南:单轴功能块常见报错排查(基于SM3_Basic函数库)

本文深入解析PLCopen运动控制中单轴功能块的常见报错问题,基于SM3_Basic函数库提供实用排查指南。从功能块逻辑错误与硬件报错的甄别技巧到高频报错场景的解决方案,帮助工程师快速定位并解决运动控制系统中的稳定性问题,提升工业自动化设备的运行效率。

weixin_33686714的博客 320

D-Star 寻路算法

D*算法:D* 算法”的名称源自 Dynamic A Star,最初由Anthony Stentz于“Optimal and Efficient Path Planning for Partially-Known Environments”中介绍。它是一种启发式的路径搜索算法, 适合面对周围环境未知或者周围环境存在动态变化的场景。

lq 2116

别再死记硬背了!用Multisim仿真5分钟搞懂运放电压跟随器到底要不要加反馈电阻

本文通过Multisim仿真实验,深入解析运放电压跟随器中反馈电阻的必要性。实验对比不同阻值对电路性能的影响,揭示反馈电阻在提供偏置电流通路、提升高频稳定性和ESD保护中的关键作用,并给出工程实践中的优化建议,帮助工程师快速掌握运放电路设计要点。

weixin_42641998的博客 372

一个高效的A-star寻路算法

这种写法比较垃圾,表现在每次搜索一个点要遍历整个地图那么大的数组,如果地图为256*256,每次搜索都要执行65535次,如果遍历多个点就是n*65535,速度上实在是太垃圾了 简单说下思路,以后补充算法 优化重点在在open表和close表的遍历上,这两个地方优化后,astar会大量提速 close只用来查询所以可以用hash这样就避免了遍历 open首先用来查询是否有相同的点如果有

merlinda_2016的博客 2372

Android音频输出流实战:从AudioFlinger到HAL层的完整调用链解析

本文深入解析了Android音频输出流的完整调用链,从应用层的AudioTrack和AAudio API,到系统服务AudioFlinger的混音调度,最终抵达硬件抽象层(HAL)。文章结合实战经验,探讨了如何利用底层机制优化音频延迟、处理设备切换,并提供了性能调优与问题排查的具体方法,是开发高性能音频应用的实用指南。

weixin_29208327的博客 252

【Bug已解决】openclaw max turns reached / Tool calls exceeded limit — OpenClaw 最大轮次超限解决方案

OpenClaw 在执行过程中达到最大轮次限制任务未完成,本质是 --max-turns 设置过小或任务过于复杂。文中给出增加轮次、--continue 继续、分步执行等完整方案。

一键难忘的博客 5506

a-star-lua:为Lua语言定制的A*寻路算法

a-star-lua:为Lua语言定制的A*寻路算法 项目介绍 在现代游戏开发、机器人导航以及众多路径规划场景中,A*(A-Star)算法是一种极为高效且广泛应用的技术。a-star-lua 项目提供了一种简洁、简单的 A* 寻路算法实现,专为 Lua 编程语言设计。它不依赖任何外部库,拥有清晰的接口,使得开发者可以轻松地根据不同的需求调整模块行为。 项目技术分析 核心功能 a-star-lua ...

gitblog_00574的博客 709

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

A星(A*, A Star)算法详解

MulinB按:经典的智能寻路算法,一个老外写的很透彻很清晰,很容易让人理解神秘的A*算法。以下是一个中文翻译版。 A*寻路初探 GameDev.net 作者: Patrick Lester 译者:Panic 2005年3月18日   译者序:很久以前就知道了A*算法,但是从未认真读过相关的文章,也没有看过代码,只是脑子里有个模糊的概念。这次决定从头开始,研究一下这个

小邓笔记 6万+

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

AAAAA——STAR寻路算法

小唐龙最近在走迷宫,可是他不知道应该怎么走,请你来帮帮他。

lbdking的博客 1808

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

A*(也叫A star, A星)寻路算法Java版

A*(也叫A star, A星)寻路算法Java版 寻路算法有很多种,A*寻路算法被公认为最好的寻路算法。 原创文章,转载请注明出处:http://blog.youkuaiyun.com/ruils/article/details/40780657

心怀产品梦的安卓码农 1万+

【算法实战】手把手带你用 C# 实现 A* (A-Star) 寻路算法

本文详细介绍了A寻路算法在游戏开发中的应用。A算法结合了Dijkstra算法的最短路径保证和贪婪算法的效率优势,通过F=G+H公式评估节点价值,其中G为实际移动成本,H为启发式预估成本。文章讲解了曼哈顿距离和欧几里得距离两种常用启发函数,并给出算法流程:维护开启列表和关闭列表,循环查找F值最小的节点,直至找到终点。最后提供了C#实现代码,使用PriorityQueue优化性能,包含节点定义、启发函数计算和路径搜索的核心逻辑。该算法是游戏自动寻路系统的关键技术,兼顾路径最优性和计算效率。

qq_42555291的博客 1554

python 实现A-Star算法

A-Star(A*)算法是一种广泛使用的启发式搜索算法,用于在图形平面或网络中找到从起点到终点的最短路径。它结合了Best-First Search算法和Dijkstra算法的特点,通过使用启发函数来指导搜索过程,从而提高搜索效率。A算法的基本原理g(n):从起点到当前节点n的实际代价。h(n):从当前节点n到目标节点的估计代价。这两个值被用来计算f(n)fngnhnfngnhn。

luthane的博客 2229

python 实现A*(A-Star)算法

A(A-Star)算法是一种广泛使用的启发式搜索算法,用于在图形平面或网络中找到从起点到终点的最短路径。它由Peter Hart、Nils Nilsson和Bertram Raphael在1968年提出,结合了Dijkstra算法的确保性(保证找到一条最短路径)和贪心算法的高效性(快速找到目标)。工作原理A*算法通过评估函数f(n) = g(n) + h(n)来工作,其中:g(n)是从起始点到任何顶点n的实际成本。h(n)是从顶点n到目标的估计最低成本,通常用启发式函数来计算。

luthane的博客 3365
上一篇: 一个高效的A-star寻路算法(八方向)
下一篇: 使用Sneaky 的源码改写的在cocos2d-x 2.x后的版本中~可以使用来遥控物体
java886o
博客等级 码龄19年 23粉丝 21原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值