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

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

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

原作者是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;
    }
}

(完)

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

相关推荐

A Star算法原理及其实现

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

大隐隐于野 9598

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

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

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

qq_62617798的博客 1893

A*自动寻路算法—java版

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

newbie的博客 8496

C# CAD2016 多边形顶点按方向重新排序

这样,通过以上步骤,我们找到了一个多边形的一个候选起始顶点(可能位于西北方向),并且已经获取了该多边形的边界框信息,这些信息对于后续判断顶点排列顺序及处理其他相关问题具有重要意义。完整地处理八个方向(东北、东南、西南、西北、北、南、东、西),我们可以创建一个方法来获取多边形相对于给定点的最近顶点及其对应的方向。对象(或类似的多边形表示方式),其中包含了多边形的顶点。//附送AI 图片无版权 随意用 龙年大吉大利。

转眼之间 一路有你 1359

固件测试工具选型需要考察的功能点汇总

通过专业的固件测试工具可以帮助我们提高测试效率、提升测试的覆盖度、确保测试的准确性,保障产品的安全和质量。本文我们讲固件测试工具的功能点进行梳理和汇总,方便大家在采购固件测试工具时进行选型比对。

daopuyun的博客 2113

ASTAR (A*)寻路基础学习,typescript

经典a*算法

EddyLwei的博客 1066

OTP语音芯片SOP8的前世今生_如九齐_硕呈_钰绅等以及国产方案KT148A

语音芯片ic的其中一个品类,就是SOP8封装的OTP语音芯片,非常的经典和常用。源头的供应商基本都是台系的原厂,比如:九齐、硕呈、佑华等等,其中佑华就算是鼻祖了,早期的4位机也是在语音市场得到了升华。 OTP(One Time Programmable)是单片机的一种存储器类型,意思是一次性可编程:程序烧入单片机后,将不可再次更改和清除。

qyvhome的博客 1875

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

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

aikb6223的博客 1256

ABAP代码检查(Code Review)

1、SLIN 扩展程序检查 也可通过(SE38工具栏->检查-扩展程序检查) 进入 2、ATC 检查 通过<SE38菜单栏-检查-ABAP测试主控室> 或事物代码SCI, 支持自定义检查变式 SCI可以配置检查变式满足特殊需求,配置对象集用于批量检查 3、通过ABAP测试主控室实现统一管理,定期检查作业和监控功能(事务代码ATC) 参考 SLIN...

u012232542的博客 6075

ROS2与Gazebo协同实现多机器人避障仿真

本文详细介绍了如何利用ROS2与Gazebo协同搭建多机器人避障仿真环境。通过创建SDF机器人模型、编写多机器人启动文件以及集成基础避障算法,构建了一个低成本、高效率的虚拟测试平台,为AGV编队、机器人集群等项目的算法验证与迭代提供了完整解决方案。

weixin_29065659的博客 299

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

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

merlinda_2016的博客 2372

AI智能体协作:构建更精准的公司破产预测模型

公司破产预测对于金融机构、投资者和监管部门等具有至关重要的意义。准确的破产预测可以帮助金融机构提前做好风险防范,避免贷款损失;投资者可以根据预测结果调整投资组合,降低投资风险;监管部门可以及时发现潜在的金融风险,采取相应的监管措施。然而,传统的公司破产预测模型往往存在精度不高的问题,无法满足实际需求。本研究的目的是利用AI智能体协作的方式,构建一个更精准的公司破产预测模型。通过将多个AI智能体的优势进行整合,充分挖掘公司财务数据、市场数据等多源数据中的信息,提高预测的准确性和可靠性。

2501_92132293的博客 1082

D-Star 寻路算法

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

lq 2116

Cadence virtuos安装教程

本文详细介绍了在Ubuntu 18.04系统上安装Cadence Virtuoso IC617及MMSIM的完整流程。主要内容包括:1)系统环境准备(安装JDK及相关依赖包);2)通过创建软链接和修改系统文件实现RedHat环境兼容;3)共享目录文件操作与分卷压缩包合并解压技巧;4)使用InstallScape工具的安装步骤详解,包括权限处理和配置选项。特别提醒需注意系统兼容性处理(如创建redhat-release文件)和分卷压缩包的特殊解压方法(cat合并)。整个安装过程涉及大量Linux命令操作,需特

wangjie36的博客 302

Week 9 10 Neural Networks

Week 9 10 Neural Networks

金州饿霸吃不饱的博客 404

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

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

gitblog_00574的博客 709

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

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

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

小邓笔记 6万+

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

AAAAA——STAR寻路算法

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

lbdking的博客 1808

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

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

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

Android For Java 1669

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
上一篇: Activity intent经常使用的 FLAG 集合
下一篇: 一个高效的A-star寻路算法(四方向)
java886o
博客等级 码龄19年 23粉丝 21原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值