A*带你踏上快车道

最新推荐文章于 2021-09-17 09:59:53 发布
最新推荐文章于 2021-09-17 09:59:53 发布
阅读量426 收藏
点赞数
分类专栏： 算法 文章标签： Astar A星算法 A星 路径规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013344815/article/details/53375607
版权
A*（A-Star)算法是一种静态路网中求解最短路最有效的直接搜索方法，也是许多其他问题的常用启发式算法。
公式表示为： f(n)=g(n)+h(n),
其中 f(n) 是从初始节点经由节点n到目标节点 的代价估计，
g(n) 是在节点空间中从初始节点到节点n的实际代价，
h(n) 是从节点n到目标节点的最佳路径的估计代价。
帮助理解A*算法的文章：
A*算法原理图文详解
A*算法之寻路初探
A*搜索算法
A*，Dijkstra，BFS算法性能比较及A*算法的应用
案例分析

以上矩阵代表某地区的地形图，节点数字为0代表该节点可以通行，节点数字1代表此处有障碍物，节点数字2代表该节点为始发点，数字3代表终点，要求找到一条由始发点到终点的最短路径（曼哈顿距离最短）。
这里运用A*算法解决，程序如下： 
package AStar;  
  
import java.util.Iterator;  
import java.util.LinkedList;  
import java.util.Queue;  

public class AStar {  
    // 开始节点  
    private Point startPoint = null;  
    // 当前节点  
    private Point endPoint = null;  
    // 结束节点  
    private Point currentPoint = null;  
    // 最短距离坐标节点  
    private Point shortestFPoint = null;  
  
    //数组地图  
    private static final int[][] mazeArray = {  
            { 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,3 },  
            { 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,1 },  
            { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1 },  
            { 1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,1 },  
            { 0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1 },  
            { 0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1,1 },  
            { 2,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1,1 },
            { 0,0,0,1,0,0,1,0,0,1,1,1,0,0,0,0,1,0,1,1 },
            { 0,0,0,0,0,1,0,0,1,0,0,0,1,1,0,0,1,0,1,0 },
            { 0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0 },
            { 0,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0 },
            { 0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0 },
            { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1 },
            { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1 },
            { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1 }
            };  
    
  
    // 地图坐标对象  
    private Point[][] mazePoint = null;  
  
    // 开启队列，用于存放待处理的节点  
    Queue<Point> openQueue = null;  
    // 关闭队列，用于存放已经处理过的节点  
    Queue<Point> closedQueue = null;  
  
    // 起始节点到某个节点的距离  
    int[][] GList = null;  
    // 某个节点到目的节点的距离  
    int[][] HList = null;  
    // 起始节点经过某个节点到目的节点的距离  
    int[][] FList = null;  

    public AStar(Point[][] mazePoint, Point startPoint, Point endPoint) {  
        this.mazePoint = mazePoint;  
        this.startPoint = startPoint;  
        this.endPoint = endPoint;  
        openQueue = new LinkedList<Point>();  
        //将元素添加到列表的末尾
        openQueue.offer(startPoint);  
  
        closedQueue = new LinkedList<Point>();  
  
        FList = new int[mazePoint.length][mazePoint[0].length];  
        GList = new int[mazePoint.length][mazePoint[0].length];  
        HList = new int[mazePoint.length][mazePoint[0].length];  
  
        for (int i = 0; i < mazePoint.length; i++) {  
            for (int j = 0; j < mazePoint[0].length; j++) {  
                FList[i][j] = Integer.MAX_VALUE;  
                GList[i][j] = Integer.MAX_VALUE;  
                HList[i][j] = Integer.MAX_VALUE;  
            }  
        }  
  
        // 起始节点到当前节点的距离  
        GList[startPoint.getX()][startPoint.getY()] = 0;  
        // 当前节点到目的节点的距离  
        HList[startPoint.getX()][startPoint.getY()] = getPointDistance(  
                startPoint.getX(), startPoint.getY(), endPoint.getX(),  
                endPoint.getY());  
        // f(x) = g(x) + h(x)  
        FList[startPoint.getX()][startPoint.getY()] = GList[startPoint.getX()][startPoint  
                .getY()] + HList[startPoint.getX()][startPoint.getY()];  
  
    }  
  
    /** 
     * 计算当前坐标与结束坐标之间的距离 
     *  
     * 计算方法为每向相信坐标移动一次算作一个距离单位 
     */  
    private int getPointDistance(int current_x, int current_y, int end_x,  
            int end_y) {  
        return Math.abs(current_x - end_x) + Math.abs(current_y - end_y);  
    }  
  
    /** 
     * 节点地图 
     *  
     * 0代表可通行 ，1代表障碍 ，2代表开始节点 ，3代表结束节点 
     *  
     */    
    public static void main(String[] args) {  

        // 创建节点地图  
        Point[][] mazePoint = new Point[mazeArray.length][mazeArray[0].length];  
        for (int i = 0; i < mazePoint.length; i++) {  
            for (int j = 0; j < mazePoint[0].length; j++) {  
                mazePoint[i][j] = new Point(i, j, mazeArray[i][j]);  
            }  
        }  
        
       
        Point start = mazePoint[6][0];  
        Point end = mazePoint[0][19];  
       
        AStar star = new AStar(mazePoint, start, end);  
        star.start();  
  
        System.out.println(mazeArray.length + "," + mazeArray[0].length);  
  
        star.printPath(); 
     
  
    }  
  
    /** 
     * 开始地图节点搜索 
     */  
    public void start() {  
        while ((currentPoint = findShortestFPoint()) != null) {  
            if (currentPoint.getX() == endPoint.getX()  
                    && currentPoint.getY() == endPoint.getY())  
                return;  
            updateNeighborPoints(currentPoint);  
        }  
    }  
  
    /** 
     * 获取距离最短的坐标点 
     * 
     */  
    public Point findShortestFPoint() {  
        currentPoint = null;
        //最短距离坐标节点
        shortestFPoint = null;  
        int shortestFValue = Integer.MAX_VALUE;  
  
        Iterator<Point> it = openQueue.iterator();  
  
        while (it.hasNext()) {  
            currentPoint = it.next();  
            if (FList[currentPoint.getX()][currentPoint.getY()] <= shortestFValue) {  
                shortestFPoint = currentPoint;  
                shortestFValue = FList[currentPoint.getX()][currentPoint.getY()];  
            }  
        }  
  
        if (shortestFValue != Integer.MAX_VALUE) {  
            System.out  
                    .println("【移除节点】:" + shortestFPoint.getValue() + "["  
                            + shortestFPoint.getX() + ","  
                            + shortestFPoint.getY() + "]");  
  
            openQueue.remove(shortestFPoint);  
            closedQueue.offer(shortestFPoint);  
        }  
  
        return shortestFPoint;  
    }  
  
    /** 
     * 更新临近节点 
     * 
     */  
    private void updateNeighborPoints(Point currentPoint) {  
        int current_x = currentPoint.getX();  
        int current_y = currentPoint.getY();  
        System.out.println("当前节点：[" + current_x + "," + current_y + "]");  
        // 上  
        if (checkPosValid(current_x - 1, current_y)) {  
            System.out.print("上");  
            updatePoint(mazePoint[current_x][current_y],  
                    mazePoint[current_x - 1][current_y]);  
        }  
        // 下  
        if (checkPosValid(current_x + 1, current_y)) {  
            System.out.print("下");  
            updatePoint(mazePoint[current_x][current_y],  
                    mazePoint[current_x + 1][current_y]);  
        }  
        // 左  
        if (checkPosValid(current_x, current_y - 1)) {  
            System.out.print("左");  
            updatePoint(mazePoint[current_x][current_y],  
                    mazePoint[current_x][current_y - 1]);  
        }  
        // 右  
        if (checkPosValid(current_x, current_y + 1)) {  
            System.out.print("右");  
            updatePoint(mazePoint[current_x][current_y],  
                    mazePoint[current_x][current_y + 1]);  
        }  
        System.out.println("---------------");  
    }  
  
    /** 
     * 检查该节点是否有效 
     * 
     */  
    private boolean checkPosValid(int x, int y) {  
        // 检查x,y是否越界， 并且当前节点不是墙  
        if ((x >= 0 && x < mazePoint.length)  
                && (y >= 0 && y < mazePoint[0].length)  
                && (mazePoint[x][y].getValue() != 1)) {  
            // 检查当前节点是否已在关闭队列中，若存在，则返回 "false"  
            Iterator<Point> it = closedQueue.iterator();  
            Point point = null;  
            while (it.hasNext()) {  
                if ((point = it.next()) != null) {  
                    if (point.getX() == x && point.getY() == y)  
                        return false;  
                }  
            }  
            return true;  
        }  
        return false;  
    }  
  
    /** 
     * 更新当前节点 
     */  
    private void updatePoint(Point lastPoint, Point currentPoint) {  
        int last_x = lastPoint.getX();  
        int last_y = lastPoint.getY();  
        int current_x = currentPoint.getX();  
        int current_y = currentPoint.getY();  
  
        // 起始节点到当前节点的距离  
        int temp_g = GList[last_x][last_y] + 1;  
        // 当前节点到目的位置的距离  
        System.out.print("  [" + current_x + "," + current_y + "]"  
                + mazePoint[current_x][current_y].getValue());  
        int temp_h = getPointDistance(current_x, current_y, endPoint.getX(),  
                endPoint.getY());  
        System.out.println("到目的位置的距离 :" + temp_h);  
        // f(x) = g(x) + h(x)  
        int temp_f = temp_g + temp_h;  
        System.out.println("f(x) = g(x) + h(x) :" + temp_f + "=" + temp_g + "+"  
                + temp_h);  
  
        // 如果当前节点在开启列表中不存在，则：置入开启列表，并且“设置”  
        // 1) 起始节点到当前节点距离  
        // 2) 当前节点到目的节点的距离  
        // 3) 起始节点到目的节点距离  
        if (!openQueue.contains(currentPoint)) {  
            openQueue.offer(currentPoint);  
            currentPoint.setFather(lastPoint);  
            System.out.println("添加到开启列表:" + currentPoint.getValue() + "["  
                    + currentPoint.getX() + "," + currentPoint.getY() + "]");  
            // 起始节点到当前节点的距离  
            GList[current_x][current_y] = temp_g;  
            // 当前节点到目的节点的距离  
            HList[current_x][current_y] = temp_h;  
            // f(x) = g(x) + h(x)  
            FList[current_x][current_y] = temp_f;  
        } else {  
  
            // 如果当前节点在开启列表中存在，并且，  
            // 从起始节点、经过上一节点到当前节点、至目的地的距离 < 上一次记录的从起始节点、到当前节点、至目的地的距离，  
            // 则：“更新”  
            // 1) 起始节点到当前节点距离  
            // 2) 当前节点到目的节点的距离  
            // 3) 起始节点到目的节点距离  
            if (temp_f < FList[current_x][current_y]) {  
                // 起始节点到当前节点的距离  
                GList[current_x][current_y] = temp_g;  
                // 当前节点到目的位置的距离  
                HList[current_x][current_y] = temp_h;  
                // f(x) = g(x) + h(x)  
                FList[current_x][current_y] = temp_f;  
                // 更新当前节点的父节点  
                currentPoint.setFather(lastPoint);  
            }  
            System.out.println("currentPoint:" + currentPoint.getValue() + "["  
                    + currentPoint.getX() + "," + currentPoint.getY() + "]");  
            System.out.println("currentPoint.father:"  
                    + currentPoint.getFather().getValue() + "["  
                    + currentPoint.getFather().getX() + ","  
                    + currentPoint.getFather().getY() + "]");  
        }  
    }  
  
    /** 
     * 打印地铁路径 
     */  
    public void printPath() {  
        System.out.println("================ 开始打印地铁路径【用 “*”表示】 ================");  
        Point father_point = null;  
        Object[][] result = new Object[mazeArray.length][mazeArray[0].length];  
        for (int i = 0; i < mazeArray.length; i++) {  
            for (int j = 0; j < mazeArray[0].length; j++) {  
                result[i][j] = 0;  
            }  
        }  
  
        int step = 0;  
        father_point = mazePoint[endPoint.getX()][endPoint.getY()];  
        while (father_point != null) {  
            System.out.println("【father_point】" + father_point.getValue() + "["  
                    + father_point.getX() + "," + father_point.getY() + "]");  
            if (father_point.equals(startPoint))  
                result[father_point.getX()][father_point.getY()] = 2;  
            else if (father_point.equals(endPoint)) {  
                result[father_point.getX()][father_point.getY()] = 3;  
                step++;  
            } else {  
                result[father_point.getX()][father_point.getY()] = "*";  
                step++;  
            }  
            father_point = father_point.getFather();  
        }  
        // 打印行走步数  
        System.out.println("step is : " + step);  
        for (int i = 0; i < mazeArray.length; i++) {  
            for (int j = 0; j < mazeArray[0].length; j++) {  
                System.out.print(result[i][j] + " ");  
            }  
            System.out.println();  
        }  
    }  
  
}  
class Point{
	private int x;
	private int y;
	private int l;
	private Point father;
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public int getValue(){
		return l;
	}
	public Point(int x,int y,int l){
		this.x=x;
		this.y=y;
		this.l=l;
	}
	public Point getFather(){
		return this.father;
	}
	public void setFather(Point Point){
		this.father=Point;
	}
	
	
}
程序运行结果：




u013344815
关注
专栏目录
人工智能大作业——A*算法迷宫寻路问题
weixin_46037153的博客
07-05 2万+
项目设计的目的 利用A*算法实现迷宫寻路功能，利用启发式函数的编写以及各类启发式函数效果的比较。 相关原理知识介绍 A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。公式表示为：f(n)=g(n)+h(n)，其中f(n)是节点n从初始点到目标点的估价函数，g(n)是在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取：估价值h(n)小于等于n到目标节点的距离实际值，这种情况下，搜索的点数多，搜索范
A*算法
除了学习谁都不爱的博客
02-13 2415
** 原理 ** A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。 A算法的公式表示为： f(n)=g(n)+h(n), 其中 f(n) 是从初始点经由节点n到目标点的估价函数，g(n) 是在状态空间中从初始节点到n节点的实际代价，h(n) 是从n到目标节点最佳路径的估计代价。 如果对A算法（全局择优）中的g(n)和h(n)分别提出如下限制：①g(n)是对最小代价g(n)的估计，且...
路径规划——A-Star算法
肥宅快乐谁
02-19 1918
你好
启发式算法-A*算法
weixin_30849403的博客
03-31 1687
A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法 A算法公式表示为： f(n)=g(n)+h(n) 其中 f(n) 是从初始点经由节点n到目标点的估价函数 g(n) 是在状态空间中从初始节点到n节点的实际代价 h(n) 是从n到目标节点最佳路径的估计代价 启发信息给得越多（估价函数值越大），则A算法需要搜索处理的状态数就越少，效率就越高。...
【人工智能】A*算法
CUIroot的博客
01-08 1571
原理*A算法，A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。估价值与实际值越接近，估价函数取得就越好。 A*[1]（A-Star)算法是一种静态路网中求解最短路最有效的方法。 公式表示为： f(n)=g(n)+h(n), 其中 f(n) 是从初始点经由节点n到目标点的估价函数， g(n) 是在状态空间中从初始节点到n节点的实际代价， h(n) 是从n到目标节点最佳路径的估
人工智能背景下会计专业学生的应对策略——基于A市地方高校问卷调查.pdf
07-10
会计专业学生应该理解未来会计行业的发展趋势，特别是管理会计的应用已经踏入快车道。国内企业中，超过80%的财务人员担任核算会计工作，而发达国家中80%以上的财务人员从事管理会计工作，他们的实践70%用于决策性...
ML学习分享系列(1)_计算广告小窥[上]
龙心尘
01-25 1万+
回顾计算广告的发展历史，纵使错综复杂，但究其根本，便是广告主、媒体与用户之间相互博弈之后达到的平衡状态。在传统广告踏入互联网大门之后，在利益最大化的驱动下，媒体通过受众定向技术引领广告进入合约广告时代；在精细化投放的使命与在线分配的矛盾下，媒体选择竞价方式将计算广告推入了发展的快车道；在广告主个性化投放的要求下，实时竞价映入眼帘，并衍生出更多的广告活动参与者；在移动互联大潮下，用户体验被尊为一切产品的出发点
电梯电气安装维修(T2)试卷及答案.docx
09-30
- **解析**: 自动扶梯和自动人行道的所有标志、说明和使用须知确实应由经久耐用的材料制成，放置于醒目位置，并采用中文书写，以确保乘客能够清楚地了解使用规则。 25. **夏季安装电梯着装要求** - **知识点**: ...
2021年T电梯修理试题及解析及T电梯修理模拟考试题库
weixin_59150731的博客
09-17 446
题库来源：安全生产模拟考试一点通公众号小程序 安全生产模拟考试一点通：T电梯修理试题及解析是安全生产模拟考试一点通总题库中生成的一套T电梯修理模拟考试题库，安全生产模拟考试一点通上T电梯修理作业手机同步练习。2021年T电梯修理试题及解析及T电梯修理模拟考试题库 1、【多选题】电梯曳引绳，有很高的要求，但不包括（）。（CD） A、抗拉 B、耐磨 C、耐热 D、耐压 2、【多选题】门光幕防夹人保护装置，由（）组成。（ABCD） A、光电管 B、控制器 C、电源 D、线...
Python实现电子词典
weixin_30586257的博客
08-12 3516
代码一览： dictionary/├── code│ ├── client.py│ ├── func.py│ ├── server.py│ └── settings.py├── data│ ├── data.py│ ├── in.txt│ ├── out.txt│ └── processor.py└── readme.txt 详细代码： ...
a star算法（A*算法）
06-17
一个关于A*算法的详细讲解 A*（A-Star)算法是一种静态路网中求解最短路最有 效的方法。
star算法
chencunheng的专栏
04-25 510
A*（A-Star)算法是一种静态路网中求解最短路最有效的方法。 公式表示为： f(n)=g(n)+h(n), 其中f(n) 是节点n从初始点到目标点的估价函数， g(n) 是在状态空间中从初始节点到n节点的实际代价， h(n)是从n到目标节点最佳路径的估计代价。 保证找到最短路径（最优解的）条件，关键在于估价函数h(n)的选取： 估价值h(n)实际值, 搜索的...
Java实现计算圆周率π的两种方法
热门推荐
磷火的博客
12-12 5万+
π≈3*2^n*y_n 其中，n代表割圆次数，y_n代表圆中内嵌正6*n边形的边长
约瑟夫环问题求解--程序+详细注解
磷火的博客
12-08 9249
约瑟夫环问题起源于一个犹太故事。约瑟夫环问题的大意如下 罗马人攻占了桥塔帕特，41个人藏在一个山洞中躲过了这场浩劫。这41个人中，包括历史学家约瑟夫和他的一个朋友。剩余的39个人为了表示不向罗马人屈服，决定集体自杀。大家决定了一个自杀方案，所有这41个人围成一个圆圈，由第1个人开始顺时针报数，每报数为3的人就立刻自杀，然后再由下一个人继续报数，仍然是每报数为3的人就立刻自杀……，直到所有人都自杀
快速排序算法——以数组最后一个元素为主元
磷火的博客
11-22 4184
关于快速排序的认识及其基本特征，请参寻我的另外一篇博文快速排序——以数组第一个元素为主元 以具体的例子
快速排序算法——以数组第一个元素为主元
磷火的博客
11-22 2430
快速排序算法的基本特性 时间复杂度：O（n*lgn） 最坏：O（n^2） 空间复杂度：O（n*lgn） 不稳定。 快速排序是一种排序算法，对包含n个数的输入数组，平均时间为O（nlgn），最坏情况是O（n^2）。 通常是用于排序的最佳选择。因为，基于比较的排序，最快也只能达到O（nlgn）。 快速排序算法的程序实现（以数组第一个元素为主元） 我的另外一篇博客也讨论了快排
分解质因数
磷火的博客
12-24 1909
在初等数论中，任何一个合数都可以写成几个质数相乘的形式，这几个质数都叫做这个合数的质因数，例如，24=2*2*2*3.分解质因数就是把一个合数写成几个质数相乘的形式。对于一个质数，它的质因数可以定义为它本身。 package 分解质因式; import java.util.Scanner; public class Example { //定义方法isSushu()，判断参数n是否为质数
算法基础--大O函数
磷火的博客
02-27 1457
驶入职场快车道：思维导图的力量
通过学习思维导图，可以帮助人们更高效地整理信息，提高记忆力和创新能力，从而进入成长的快车道。书中提到，我们的大脑具有巨大的潜能，但往往没有得到充分利用，因此需要掌握如何正确使用大脑的方法。" 详细知识...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值