A*算法的理解

最新推荐文章于 2025-07-15 23:46:03 发布
原创 最新推荐文章于 2025-07-15 23:46:03 发布 · 1.1k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

网上查找的A*算法，通过对八数码问题的讲解来解释A*算法的具体使用过程，很详细很完全，因此留下一点学习的脚印 

 

 

代码如下：

语言： Java   操作系统：Mac OS   环境：IDEA

import java.util.ArrayList;
import java.util.Arrays;
import static com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util.println;


//  自定义一个队列的参数，内有一个F(n)的int和一个数组
class List_Elem{
    int Fresult;
    int Hresult;
    int[] list;
}
public class test2 {
    /**
     * 方发快，使用A*算法计算八数码问题
     * 方法传入两个矩阵作为参数，一个原始矩阵，一个目标矩阵
     * 通过A*算法，将原始矩阵转换成目标矩阵，如果成功，则输出最少的移动步数，如果失败，返回false
     */
    private int []Ffunction = new int[8];

    public static void main(String arge[]){
        int[] orarray = {2,8,3,1,0,4,7,6,5};
        int[] targetarray = {1,2,3,8,0,4,7,6,5};
        List_Elem Templist = new List_Elem();
        int count = 0;//  记录循环的次数，该参数可以直接作为G(n)
        //  首先找到0的位置
        int temp = 0;
        int i = 0;
        int flag = 0;
        //  主代码快
        //  将目标矩阵和初始矩阵转化为数组形式
        //  用于存储每一次移动后形成的矩阵对应的数组
        ArrayList<List_Elem> resultlist = new ArrayList<>();
        //  将第一个数组放入到队列中
        List_Elem tempelem = new List_Elem();
        tempelem.list = orarray;
        tempelem.Fresult = 4;
        tempelem.Hresult = 4;
        resultlist.add(tempelem);
        //  用于记录每一步 的所有可能性，找到最小F(n)
        ArrayList<List_Elem> treeList = new ArrayList<>();
        for(;;){
            /**
             * 通过A*算法的思想，进行遍历搜索，根据f(n)=g(n)+h(n)的形式，找出f（n）最小的方向，进行遍历
             * 定义一个f(n)，假设(n)表示矩阵中不在位的元素到目标位置的曼哈顿距离之和，G(n)表示的是已经进行的
             * 移动次数
             */
            Templist = new List_Elem();
            count = 0;
            i = 0;
            for (; ; ) {
                if (resultlist.get(resultlist.size() - 1).list[i] == 0) break;
                else i++;
            }
            //  对零位置的按上下左右进行移动，改变矩阵，找到F(N)最小的一种移动方式
            //  如果零位置上方存在元素，与之交换位置
            if (i - 3 >= 0) {
                ///  学习：Java中的arraylist不可以直接转换给其他参数修改，只能修改其中的元素
                Templist.list = new int[9];
                for (int k = 0; k < 9; k++) {
                    Templist.list[k] = Integer.valueOf(resultlist.get(resultlist.size() - 1).list[k]);
                }
                temp = resultlist.get(resultlist.size() - 1).list[i - 3];
                Templist.list[i - 3] = resultlist.get(resultlist.size() - 1).list[i];
                Templist.list[i] = temp;
                //  交换位置后，对比目标矩阵，求出曼哈顿距离H(n)的值，并且求出F(n)
                for (int j = 0; j < 9; j++) {
                    for (int k = 0; k < 9; k++) {
                        //  找出位置不同的元素，求出距离之和
                        if (Templist.list[j] == targetarray[k]) {
                            int step = 0;
                            if (k / 3 == j / 3)
                                step = Math.abs(j - k);
                            else if (k / 3 > j / 3) {
                                step = Math.abs(k / 3 - j / 3) + Math.abs(j + (k / 3 - j / 3) * 3 - k);
                            } else if (k / 3 < j / 3) {
                                step = Math.abs(k / 3 - j / 3) + Math.abs(j + (k / 3 - j / 3) * 3 - k);
                            }
                            Templist.Fresult = Templist.Fresult + Math.abs(step) + count;
                            Templist.Hresult = Templist.Hresult + Math.abs(step);
                            break;
                        }
                    }
                }
                for(int k= 0;k<=resultlist.size()-1;k++){
                    if(Arrays.equals(Templist.list,resultlist.get(k).list))
                    {flag =1;break;}
                    //  将其存入treelist中
                }
                if(flag==0)treeList.add(Templist);
            }
            /////////////////////////////////////////
            //  如果零位置的下方位置中存在元素的话，进行下一步
            if (i + 3 <= 8) {
                Templist = new List_Elem();
                Templist.list = new int[9];
                for(int k=0;k<9;k++){
                    Templist.list[k] = Integer.valueOf(resultlist.get(resultlist.size() - 1).list[k]);
                }
                temp = resultlist.get(resultlist.size() - 1).list[i + 3];
                Templist.list[i + 3] = resultlist.get(resultlist.size() - 1).list[i];
                Templist.list[i] = temp;
                //  交换位置后，对比目标矩阵，求出曼哈顿距离H(n)的值，并且求出F(n)
                for (int j = 0; j < 9; j++) {
                    for (int k = 0; k < 9; k++) {
                        //  找出位置不同的元素，求出距离之和
                        if (Templist.list[j] == targetarray[k]) {
                            int step = 0;
                            if (k / 3 == j / 3)
                                step = Math.abs(j - k);
                            else if (k / 3 > j / 3) {
                                step = Math.abs(k / 3 - j / 3) + Math.abs(j + (k / 3 - j / 3) * 3 - k);
                            } else if (k / 3 < j / 3) {
                                step = Math.abs(k / 3 - j / 3) + Math.abs(j + (k / 3 - j / 3) * 3 - k);
                            }
                                Templist.Fresult =Templist.Fresult+ Math.abs(step) + count;
                                Templist.Hresult = Templist.Hresult+Math.abs(step);
                                break;
                        }
                    }
                }
                for(int k= 0;k<=resultlist.size()-1;k++){
                    if(Arrays.equals(Templist.list,resultlist.get(k).list))
                    {flag =1;break;}
                    else flag = 0;
                    //  将其存入treelist中
                }
                if(flag==0)treeList.add(Templist);
            }
            /////////////////////////////////
            ///   当零元素左边存在元素时，进行下一步
            if (i / 3 == (i - 1) / 3&&i-1>=0) {
                Templist = new List_Elem();
                Templist.list = new int[9];
                for(int k=0;k<9;k++){
                    Templist.list[k] = Integer.valueOf(resultlist.get(resultlist.size() - 1).list[k]);
                }
                temp = resultlist.get(resultlist.size() - 1).list[i - 1];
                Templist.list[i - 1] = resultlist.get(resultlist.size() - 1).list[i];
                Templist.list[i] = temp;
                //  交换位置后，对比目标矩阵，求出曼哈顿距离H(n)的值，并且求出F(n)
                for (int j = 0; j < 9; j++) {
                    for (int k = 0; k < 9; k++) {
                        //  找出位置不同的元素，求出距离之和
                        if (Templist.list[j] == targetarray[k]) {
                            int step = 0;
                            if (k / 3 == j / 3)
                                step = Math.abs(j - k);
                            else if (k / 3 > j / 3) {
                                step = Math.abs(k / 3 - j / 3) + Math.abs(j + (k / 3 - j / 3) * 3 - k);
                            } else if (k / 3 < j / 3) {
                                step = Math.abs(k / 3 - j / 3) + Math.abs(j + (k / 3 - j / 3) * 3 - k);
                            }
                                Templist.Fresult =Templist.Fresult+ Math.abs(step) + count;
                                Templist.Hresult = Templist.Hresult+Math.abs(step);
                                break;
                        }
                    }
                }
                for(int k= 0;k<=resultlist.size()-1;k++){
                    if(Arrays.equals(Templist.list,resultlist.get(k).list))
                    {flag =1;break;}
                    else flag = 0;
                    //  将其存入treelist中
                }
                if(flag==0)treeList.add(Templist);
            }
            ////////////////////////////////
            //  当零元素的右边存在元素时，进行下一步
            if (i / 3 == (i + 1) / 3&&i+1<=8) {
                Templist = new List_Elem();
                Templist.list = new int[9];
                for(int k=0;k<9;k++){
                    Templist.list[k] = Integer.valueOf(resultlist.get(resultlist.size() - 1).list[k]);
                }
                temp = resultlist.get(resultlist.size() - 1).list[i + 1];
                Templist.list[i + 1] = resultlist.get(resultlist.size() - 1).list[i];
                Templist.list[i] = temp;
                //  交换位置后，对比目标矩阵，求出曼哈顿距离H(n)的值，并且求出F(n)
                for (int j = 0; j < 9; j++) {
                    for (int k = 0; k < 9; k++) {
                        //  找出位置不同的元素，求出距离之和
                        if (Templist.list[j] == targetarray[k]) {
                            int step = 0;
                            if (k / 3 == j / 3)
                                step = Math.abs(j - k);
                            else if (k / 3 > j / 3) {
                                step = Math.abs(k / 3 - j / 3) + Math.abs(j + (k / 3 - j / 3) * 3 - k);
                            } else if (k / 3 < j / 3) {
                                step = Math.abs(k / 3 - j / 3) + Math.abs(j + (k / 3 - j / 3) * 3 - k);
                            }
                                Templist.Fresult =Templist.Fresult+ Math.abs(step) + count;
                                Templist.Hresult = Templist.Hresult+Math.abs(step);
                                break;
                        }
                    }
                }
                for(int k= 0;k<=resultlist.size()-1;k++){
                    if(Arrays.equals(Templist.list,resultlist.get(k).list))
                    {flag =1;break;}
                    else flag = 0;
                    //  将其存入treelist中
                }
                if(flag==0)treeList.add(Templist);
            }
            // 四个方法找到所有可能性后，进行比较，找到F(n)最小的一个方向,存入ResultList，在进行查找，直到ResultList最后一个参数的FResult=0
            int num = 1;
            int min = 0;
            while (num<treeList.size()) {
                //  找到最小的曼哈顿距离之和，将其存入resultlist中，之后清空treelist
                if (treeList.get(num).Hresult < treeList.get(min).Hresult)
                    min = num;
                num++;
            }
            //  赋值，清空
            resultlist.add(treeList.get(min));
            treeList.clear();

            if(resultlist.get(resultlist.size()-1).Hresult==0)break;
        }
        println("该八数码问题有解，最短步骤如下：");
        println("初始位置：");for(int w=0;w<9;w++){
            System.out.print(resultlist.get(0).list[w]);
        }
        println("");
        println("A*算法求得的最短变化过程：");
        for(int out = 1;out<=resultlist.size()-1;out++){
            for(int w = 0;w<9;w++){
                if(resultlist.get(out)!=null)
                System.out.print(resultlist.get(out).list[w]);
            }
            println("");
        }
    }
}

 

路径规划算法 | A* 搜索算法
一点人工一点智能的博客
04-24 2675
A*搜索算法是一种用于路径搜索和图遍历的效果很好、主流的技术之一。
基于matlab的双向A*算法
04-30
首先，我们来详细理解A*算法的基本原理。A*算法通过评估两个度量来确定节点的优先级：一个是实际已走过的代价（g值），另一个是从当前节点到目标节点的预计代价（h值）。这两个值相加得到f值，用于决定节点的优先级...
1.board------对应A*算法的路径，其实就是个矩阵，并没有什么重要的。
10-17
请不要下载，这份文档对应于A*的文件，相当于读取路径的一份文件，如果你不是从博客中过来的，请不要下载，因为对你无用。博客地址：https://blog.youkuaiyun.com/ouyangandy/article/details/102607670
A*算法的具体思想（我见过的写的最好的一份）
12-28
A*算法的具体思想（我见过的写的最好的一份） A*算法的具体思想（我见过的写的最好的一份）
A*算法详解
最新发布
07-15 2854
从游戏中的角色寻路到机器人导航，从地图软件的路线规划到无人机路径优化，A*算法都发挥着核心作用，本文我将深入解析A*算法的核心原理、实现步骤、启发函数设计及实际应用，并结合Java代码示例，带你全面掌握这一路径搜索算法。
A*算法完全理解
weixin_30734435的博客
05-31 170
注：原文出自Patrick Lester，一稿翻译为Panic。很久以前的老文章了，但我觉得真的非常的经典，想把它完善一下让以后的人能够更好的体会原作者和原翻译的精髓吧。我在此基础上修改了部分译文，更新了部分错误，在此对两位前辈表示最高的致意！ 以下是原文： 在看下面这篇文章之前，先介绍几个理论知识，有助于理解A*算法。 启发式搜索：启发式搜索就是在状态空间中的搜索对每一个搜索的...
A*算法个人理解
qq_40846446的博客
02-16 840
A*算法是游戏中常用的寻路算法，不管在2D还是3D中，只要是多场景，或者是比较大的场景，需要用到寻路来提示移动角色的都需要用到寻路算法，寻路算法有很多种， 还有递归, 非递归, 广度优先, 深度优先, 使用堆栈等等, 有兴趣的可以研究研究~~。这里主要说A*算法的个人理解。
A*算法学习（python代码实现）
05-17
A*算法是一种在图形搜索中用于寻找从起点到终点最短路径的有效算法，它结合了Dijkstra算法的全局最优性和Greedy...通过运行`my_Astar_test.py`，我们可以看到算法在不同地图上的寻路效果，直观地理解A*算法的工作原理。
移动机器人路径规划 几种A*算法改进matlab实现
12-05
对于初学者来说，这个资料包提供了一个良好的起点，通过阅读和运行代码，可以直观理解A*算法的工作原理及其在实际路径规划中的应用。同时，也可以根据自己的需求对算法进行进一步的改进和优化，以适应不同场景下的...
基于matlab实现的RRT算法、双向RRT算法、A*算法、PRM、模糊路径规划算法、遗传算法路径规划
12-31
4. **A*算法**：A*是一种启发式搜索算法，它结合了Dijkstra算法和优先级队列。A*使用一个估价函数（通常是欧几里得距离加上一个障碍物权重）来指导搜索，确保找到从起点到终点的最短路径。A*算法非常有效，但需要...
A*算法Java/C++实现
05-10
总的来说，理解和实现A*算法需要对图论、数据结构和搜索算法有深入的理解。在Java和C++中实现A*算法，可以提高我们对这两种语言特性的掌握，同时也为我们提供了一个强大的工具，用于解决游戏路径规划、机器人导航、...
A* 算法详解（超级详细讲解，附有大图）
aliyonghang的博客
01-01 2万+
今天想跟大家聊的，是我们经常用到，但是却让大家觉得十分神秘的那个算法：A*。这是一个远古而又非常经典的游戏——红警和玩的时候，就会发现这里面的兵，你只要指定好地点，他们就会自己朝目的地进发，最终去向你指定的地点。。。（这段是看了参考资料【1】之后乱编出来的）很多游戏也是这样，它会将你指定的人物，以一定的路径，到达某地（逐渐抽象）。简单来说，就是。在游戏，乃至生活之中，在很多地方会有寻路的需求。而我们因为各种原因，总会寻求最短的路线，在计算机科学中，这种寻求最短路径的问题统称为。
（2-2）A*算法：A*算法的核心思想
码农三叔
12-21 1748
选择适当的启发式函数对A*算法的性能至关重要，启发式函数（heuristic function）用于估计从当前节点到目标节点的代价，以指导搜索过程。（5）最后，通过 PrintPath 函数从目标节点开始，根据记录的父节点信息一步步回溯到起始节点，并将路径上的节点标记为 2。（2）接着，使用A*算法在迷宫中遍历节点的邻居，计算实际代价和启发式函数值，选择代价最小的路径进行探索。（2）然后，实现了A*搜索算法，通过优先队列选择估计代价最小的节点，依据欧几里得距离作为启发式函数，以达到最短路径的目标。
A* 算法讲解
weixin_30826761的博客
12-04 456
在看下面这篇文章之前，先介绍几个理论知识，有助于理解A*算法。 启发式搜索：启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。 估价函数：从当前节点移动到目标节点的预估费用；这个估计就是启发式的。在寻路问题和迷...
A*寻路算法
菜鸡的博客
11-02 8142
转载自：http://www.cppblog.com/christanxw/archive/2006/04/07/5126.html 原文地址：http://www.gamedev.net/reference/articles/article2003.asp 概述 虽然掌握了A*算法的人认为它容易，但是对于初学者来说，A*算法还是很复杂的。 搜索区域(The Search Area) 我们假设某人要从A点移动到B点，但是这两点之间被一堵墙隔开。如图1，绿色是A，红色是...
伴随矩阵A*
人工智能视觉分析算法学习实践和经验分享。
05-31 16万+
伴随矩阵的定义： 注意点 定义矩阵A是方阵。 余子式：伴随矩阵的每个元素的余子式是除去当前元素行列，剩下的元素构成的行列式。 代数余子式：取行列式的值，符号由当前行标和列标的值决定（-1的i+j次幂）。 位置关系为转置。 计算实例： 例1：求矩阵A的伴随矩阵，其中行列式 An∗n=∣12−1310−1−1−2∣ \mathbf{A}_{n*n} = \begin{vmatrix} \mathbf{1} & \mathbf{2} & \mathbf{-1} \\ \mathbf{
矩阵的算法
qishibo1990的专栏
04-11 767
(1)矩阵的加、减运算 C(i,j)=a(i,j)+b(i,j) 加法 C(i,j)=a(i,j)-b(i,j) 减法 (2)矩阵相乘 (矩阵A有M*L个元素，矩阵B有L*N个元素，则矩阵C=A*B有M*N个元素)。矩阵C中任一元素 (i=1,2,…,m; j=1,2,…,n) #define M 2 #define L 4 #define N 3 void mv(int a[M][L], int
A*算法详解（讲的一级棒 ）
热门推荐
NL的博客
08-23 18万+
转自：https://blog.youkuaiyun.com/hitwhylz/article/details/23089415 概述 虽然掌握了 A* 算法的人认为它容易，但是对于初学者来说， A* 算法还是很复杂的。 搜索区域(The Search Area) 我们假设某人要从 A 点移动到 B 点，但是这两点之间被一堵墙隔开。如图 1 ，绿色是 A ，红色是 B ，中间蓝色是墙。 图 ...
深入理解经典A*算法C++源码解析
### 知识点详解 #### A*算法概念 A*算法是一种在图形平面上，有多个节点的...在学习和使用A*算法C++版的源码时，重点需要理解算法的逻辑流程以及类和函数之间的交互关系，这对于深化算法知识和编程技能都有很大帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值