精华内容
下载资源
问答
  • a*算法流程图(只是流程图)A*算法是一种在静态路网中求解最短路径最有效的直接搜索方法,也是解决许多其他搜索问题的有效算法。算法中的距离估算值与实际值越接近,扩展的节点数越少, 搜索速度越快。
  • A星寻路算法流程详解

    千次阅读 2017-08-18 17:59:17
    所示简易地图,其中绿色方块的是起点,中间蓝色的障碍物,红色方块表示目的地,我们用一个二位数组来表示地图。 2.寻路步骤 1. 从起点 A 开始, 把它作为待处理的方格存入一个"开启列表", 开启列表就是一个等待...

    1.简易地图

    如图所示简易地图,其中绿色方块的是起点,中间蓝色的障碍物,红色方块表示目的地,我们用一个二位数组来表示地图。

    2.寻路步骤


    1. 从起点 A 开始, 把它作为待处理的方格存入一个"开启列表", 开启列表就是一个等待检查方格 的列表.

    2. 寻找起点 A 周围可以到达的方格, 将它们放入"开启列表", 并设置它们的"父方格"为 A.

    3. 从"开启列表"中删除起点 A, 并将起点 A 加入"关闭列表", "关闭列表"中存放的都是不需要再次检查的方格 

       从 "开启列表" 中找出相对最靠谱的方块, 什么是最靠谱? 它们通过公式 F=G+H 来计算.
      F = G + H                
      G 表示从起点 A 移动到网格上指定方格的移动耗费 (可沿斜方向移动).
            H 表示从指定的方格移动到终点 B 的预计耗费 (H 有很多计算方法, 这里我们设定只可以 上下左右移动). 
     从 "开启列表" 中选择 F 值最低的方格 C (绿色起始方块 A 右边的方块), 然后对它进行如下处 理:

    4. 把它从 "开启列表" 中删除, 并放到 "关闭列表" 中.         

    5. 检查它所有相邻并且可以到达 (障碍物和 "关闭列表" 的方格都不考虑) 的方格. 如果这些方格 还不在 "开启列表" 里的话, 将它们加入 "开启列表", 计算这些方格的 G, H 和 F 值各是多少, 并设置 它们的 "父方格" 为 C.         

    6. 如果某个相邻方格 D 已经在 "开启列表" 里了, 检查如果用新的路径 (就是经过 C 的路径) 到 达它的话, G 值是否会更低一些, 如果新的 G 值更低, 那就把它的 "父方格" 改为目前选中的方格 C, 然 后重新计算它的 F 值和 G 值 (H 值不需要重新计算, 因为对于每个方块, H 值是不变的). 如果新的 G 值比较高, 就说明经过 C 再到达 D 不是一个明智的选择, 因为它需要更远的路, 这时我们什么也不做. 

     3.如何找回路径


    除了起始方块, 每一个曾经或者现在还在 "开启列表" 里的方块, 它都有一个 "父方 块", 通过 "父方块" 可以索引到最初的 "起始方块", 这就是路径. 
    具体我们用代码解释

    4.代码分析

    首先我们需要为地图的格子创建一个Model包含地图每一格的信息,
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class Point {
        public Point Parent { get; set; }
        public float H;
        public int X;
        public int Y;
        public float G;
        public float F;
        public bool IsWall;
        public Point(int x,int y,Point parent=null)
        {
            this.X = x;
            this.Y = y;
            this.Parent = parent;
        }
        public void UpdateParent(Point parent,float g)
        {
            this.Parent = parent;
            this.G = g;
            this.F = G+H;
        }
    }
    然后重点就是寻路算法的代码
        /// <summary>
        /// 查找最优路径
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        private void FindPath(Point start, Point end)
        {
            List<Point> openList = new List<Point>();
            List<Point> closeList = new List<Point>();
            openList.Add(start);    //将开始位置添加进Open列表
            while (openList.Count > 0)//查找退出条件
            {
                Point point = FindMinFOfPoint(openList);//查找Open列表中最小的f值
                //print(point.F+";"+point.X+","+point.Y);
                openList.Remove(point); closeList.Add(point);//不再考虑当前节点
    
                List<Point> surroundPoints = GetSurroundPoints(point);//得到当前节点的四周8个节点
                PointsFilter(surroundPoints, closeList);//将周围节点中已经添加进Close列表中的节点移除
                foreach (Point surroundPoint in surroundPoints)
                {
                    if (openList.IndexOf(surroundPoint) > -1)//如果周围节点在open列表中
                    {
                        float nowG = CalcG(surroundPoint, surroundPoint.Parent);//计算经过的Open列表中最小f值到周围节点的G值
                        if (nowG < surroundPoint.G)
                        {
                            surroundPoint.UpdateParent(point, nowG);
                        }
                    }
                    else//周围节点不在Open列表中
                    {
                        surroundPoint.Parent = point;//设置周围列表的父节点
                        CalcF(surroundPoint, end);//计算周围节点的F,G,H值
                        openList.Add(surroundPoint);//最后将周围节点添加进Open列表
                    }
                }
                //判断一下退出条件
                if (openList.IndexOf(end) > -1)
                {
                    break;
                }
            }
    
        }
    主要就是通过获取比较F的值,每次获取到open列表中最小F的节点,并将它添加进close列表中。

    比如第一次获取到最小值为0,那么就获取到0周围的所有节点,并将他们的父节点设置为0,如果他是可以通过的就将他添加进open列表中。并将0添加进close列表中,以后不再考虑0这个节点
    7.46,5.4
    6,0,4
    7.4, 6,5.4
    第二次获取到最小值为4,重复第一步,由于4的周围没有新节点。不做操作。此时open列表中还剩7.4,6,5.4这三个值,0,4已经不再考虑,并且0没有父节点,4的父节点为0
    7.46,5.4
    6,,
    7.46,5.4
    第三次获取到最小值为5.4,这时有2个值同为5.4,没关系,我们接着往下运行,先走右上方5.4,open列表中添加7.4和8
    9.4, 8,7.4, 7.4
    7.46,,
    6,,,
    7.46,5.4
    这样依次往下运行,一步步向终点靠近,最先到达终点的点,他的一层层父节点就是我们得到的最短路径。这就是A星算法,每次和节点的四周比较获取最优点。
    然后附上完整代码
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class AStar : MonoBehaviour
    {
        private const int mapWith = 15;
        private const int mapHeight = 15;
    
        private Point[,] map = new Point[mapWith, mapHeight];
    
        // Use this for initialization
        void Start()
        {
            InitMap();  //初始化地图
            Point start = map[2, 2];
            Point end = map[6, 2];
            FindPath(start, end);
            ShowPath(start, end);
        }
    
    
        private void ShowPath(Point start, Point end)
        {
            int z = -1;
            Point temp = end;
            while (true)
            {
                //Debug.Log(temp.X + "," + temp.Y);
                Color c = Color.gray;
                if (temp == start)
                {
                    c = Color.green;
                }
                else if (temp == end)
                {
                    c = Color.red;
                }
                CreateCube(temp.X, temp.Y,z, c);
    
                if (temp.Parent == null)
                    break;
                temp = temp.Parent;
            }
            for (int x = 0; x < mapWith; x++)
            {
                for (int y = 0; y < mapHeight; y++)
                {
                    if (map[x, y].IsWall)
                    {
                        CreateCube(x, y,z, Color.blue);
                    }
                }
            }
        }
    
        private void CreateCube(int x, int y,int z, Color color)
        {
            GameObject go = GameObject.CreatePrimitive(PrimitiveType.Cube);
            go.name = x+","+y;
            go.transform.position = new Vector3(x, y, z);
            go.GetComponent<Renderer>().material.color = color;
        }
    
        private void InitMap()
        {
            for (int x = 0; x < mapWith; x++)
            {
                for (int y = 0; y < mapHeight; y++)
                {
                    map[x, y] = new Point(x, y);
                    CreateCube(x, y,0, Color.black);
                }
            }
            map[4, 1].IsWall = true;
            map[4, 2].IsWall = true;
            map[4, 3].IsWall = true;
            map[4, 4].IsWall = true;
            map[4, 5].IsWall = true;
            map[4, 6].IsWall = true;
        }
        /// <summary>
        /// 查找最优路径
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        private void FindPath(Point start, Point end)
        {
            List<Point> openList = new List<Point>();
            List<Point> closeList = new List<Point>();
            openList.Add(start);    //将开始位置添加进Open列表
            while (openList.Count > 0)//查找退出条件
            {
                Point point = FindMinFOfPoint(openList);//查找Open列表中最小的f值
                print(point.F + ";" + point.X + "," + point.Y);
                openList.Remove(point); closeList.Add(point);//不再考虑当前节点
    
                List<Point> surroundPoints = GetSurroundPoints(point);//得到当前节点的四周8个节点
                PointsFilter(surroundPoints, closeList);//将周围节点中已经添加进Close列表中的节点移除
                foreach (Point surroundPoint in surroundPoints)
                {
                    if (openList.IndexOf(surroundPoint) > -1)//如果周围节点在open列表中
                    {
                        float nowG = CalcG(surroundPoint, surroundPoint.Parent);//计算经过的Open列表中最小f值到周围节点的G值
                        if (nowG < surroundPoint.G)
                        {
                            print("123");
                            surroundPoint.UpdateParent(point, nowG);
                        }
                    }
                    else//周围节点不在Open列表中
                    {
                        surroundPoint.Parent = point;//设置周围列表的父节点
                        CalcF(surroundPoint, end);//计算周围节点的F,G,H值
                        openList.Add(surroundPoint);//最后将周围节点添加进Open列表
                    }
                }
                //判断一下
                if (openList.IndexOf(end) > -1)
                {
                    break;
                }
            }
    
        }
    
        private void PointsFilter(List<Point> src, List<Point> closeList)
        {
            foreach (Point p in closeList)
            {
                if (src.IndexOf(p) > -1)
                {
                    src.Remove(p);
                }
            }
        }
    
        private List<Point> GetSurroundPoints(Point point)
        {
            Point up = null, down = null, left = null, right = null;
            Point lu = null, ru = null, ld = null, rd = null;
            if (point.Y < mapHeight - 1)
            {
                up = map[point.X, point.Y + 1];
            }
            if (point.Y > 0)
            {
                down = map[point.X, point.Y - 1];
            }
            if (point.X > 0)
            {
                left = map[point.X - 1, point.Y];
            }
            if (point.X < mapWith - 1)
            {
                right = map[point.X + 1, point.Y];
            }
            if (up != null && left != null)
            {
                lu = map[point.X - 1, point.Y + 1];
            }
            if (up != null && right != null)
            {
                ru = map[point.X + 1, point.Y + 1];
            }
            if (down != null && left != null)
            {
                ld = map[point.X - 1, point.Y - 1];
            }
            if (down != null && right != null)
            {
                rd = map[point.X + 1, point.Y - 1];
            }
            List<Point> list = new List<Point>();
            if (down != null && down.IsWall == false)
            {
                list.Add(down);
            }
            if (up != null && up.IsWall == false)
            {
                list.Add(up);
            }
            if (left != null && left.IsWall == false)
            {
                list.Add(left);
            }
            if (right != null && right.IsWall == false)
            {
                list.Add(right);
            }
            if (lu != null && lu.IsWall == false && left.IsWall == false && up.IsWall == false)
            {
                list.Add(lu);
            }
            if (ld != null && ld.IsWall == false && left.IsWall == false && down.IsWall == false)
            {
                list.Add(ld);
            }
            if (ru != null && ru.IsWall == false && right.IsWall == false && up.IsWall == false)
            {
                list.Add(ru);
            }
            if (rd != null && rd.IsWall == false && right.IsWall == false && down.IsWall == false)
            {
                list.Add(rd);
            }
            return list;
        }
    
        private Point FindMinFOfPoint(List<Point> openList)
        {
            float f = float.MaxValue;
            Point temp = null;
            foreach (Point p in openList)
            {
                if (p.F < f)
                {
                    temp = p;
                    f = p.F;
                }
            }
            print("返回open列表中最小的f:"+temp.F);
            return temp;
        }
    
        private float CalcG(Point now, Point parent)
        {
            return Vector2.Distance(new Vector2(now.X, now.Y), new Vector2(parent.X, parent.Y)) + parent.G;
        }
    
        private void CalcF(Point now, Point end)
        {
            //F = G + H
            float h = Mathf.Abs(end.X - now.X) + Mathf.Abs(end.Y - now.Y);
            float g = 0;
            if (now.Parent == null)
            {
                g = 0;
            }
            else
            {
                g = Vector2.Distance(new Vector2(now.X, now.Y), new Vector2(now.Parent.X, now.Parent.Y)) + now.Parent.G;
            }
            float f = g + h;
            now.F = f;
            now.G = g;
            now.H = h;
        }
    }
    代码演示是在unity中实现的

    展开全文
  • A* 寻路算法 ...概述 虽然掌握了A*算法的人认为它容易,但是对于初学者来说,A*算法还是很复杂的。 搜索区域(The Search Area) 我们假设某人要从A点移动到B点,但是这两点之间被一堵墙隔开。如1,绿色是A,红色是B

    A* 寻路算法

    原文地址: http://www.gamedev.net/reference/articles/article2003.asp

    概述

    虽然掌握了 A* 算法的人认为它容易,但是对于初学者来说, A* 算法还是很复杂的。

    搜索区域(The Search Area)

    我们假设某人要从 A 点移动到 B 点,但是这两点之间被一堵墙隔开。如图 1 ,绿色是 A ,红色是 B ,中间蓝色是墙。

    image001.jpg

    图 1

    你应该注意到了,我们把要搜寻的区域划分成了正方形的格子。这是寻路的第一步,简化搜索区域,就像我们这里做的一样。这个特殊的方法把我们的搜索区域简化为了 2 维数组。数组的每一项代表一个格子,它的状态就是可走 (walkalbe) 和不可走 (unwalkable) 。通过计算出从 A 到 B需要走过哪些方格,就找到了路径。一旦路径找到了,人物便从一个方格的中心移动到另一个方格的中心,直至到达目的地。

    方格的中心点我们成为“节点 (nodes) ”。如果你读过其他关于 A* 寻路算法的文章,你会发现人们常常都在讨论节点。为什么不直接描述为方格呢?因为我们有可能把搜索区域划为为其他多变形而不是正方形,例如可以是六边形,矩形,甚至可以是任意多变形。而节点可以放在任意多边形里面,可以放在多变形的中心,也可以放在多边形的边上。我们使用这个系统,因为它最简单。

    开始搜索(Starting the Search)

    一旦我们把搜寻区域简化为一组可以量化的节点后,就像上面做的一样,我们下一步要做的便是查找最短路径。在 A* 中,我们从起点开始,检查其相邻的方格,然后向四周扩展,直至找到目标。

    我们这样开始我们的寻路旅途:

    1.       从起点 A 开始,并把它就加入到一个由方格组成的 open list( 开放列表 ) 中。这个 open list 有点像是一个购物单。当然现在 open list 里只有一项,它就是起点 A ,后面会慢慢加入更多的项。 Open list 里的格子是路径可能会是沿途经过的,也有可能不经过。基本上 open list 是一个待检查的方格列表。

    2.       查看与起点 A 相邻的方格 ( 忽略其中墙壁所占领的方格,河流所占领的方格及其他非法地形占领的方格 ) ,把其中可走的 (walkable) 或可到达的 (reachable) 方格也加入到 open list 中。把起点 A 设置为这些方格的父亲 (parent node 或 parent square) 。当我们在追踪路径时,这些父节点的内容是很重要的。稍后解释。

    3.       把 A 从 open list 中移除,加入到 close list( 封闭列表 ) 中, close list 中的每个方格都是现在不需要再关注的。

    如下图所示,深绿色的方格为起点,它的外框是亮蓝色,表示该方格被加入到了 close list 。与它相邻的黑色方格是需要被检查的,他们的外框是亮绿色。每个黑方格都有一个灰色的指针指向他们的父节点,这里是起点 A 。

    image002.jpg

    图 2 。

    下一步,我们需要从 open list 中选一个与起点 A 相邻的方格,按下面描述的一样或多或少的重复前面的步骤。但是到底选择哪个方格好呢?具有最小 F 值的那个。

     

    路径排序(Path Sorting)

    计算出组成路径的方格的关键是下面这个等式:

    F = G + H

    这里,

    G = 从起点 A 移动到指定方格的移动代价,沿着到达该方格而生成的路径。

    H = 从指定的方格移动到终点 B 的估算成本。这个通常被称为试探法,有点让人混淆。为什么这么叫呢,因为这是个猜测。直到我们找到了路径我们才会知道真正的距离,因为途中有各种各样的东西 ( 比如墙壁,水等 ) 。本教程将教你一种计算 H 的方法,你也可以在网上找到其他方法。

    我们的路径是这么产生的:反复遍历 open list ,选择 F 值最小的方格。这个过程稍后详细描述。我们还是先看看怎么去计算上面的等式。

    如上所述, G 是从起点A移动到指定方格的移动代价。在本例中,横向和纵向的移动代价为 10 ,对角线的移动代价为 14 。之所以使用这些数据,是因为实际的对角移动距离是 2 的平方根,或者是近似的 1.414 倍的横向或纵向移动代价。使用 10 和 14 就是为了简单起见。比例是对的,我们避免了开放和小数的计算。这并不是我们没有这个能力或是不喜欢数学。使用这些数字也可以使计算机更快。稍后你便会发现,如果不使用这些技巧,寻路算法将很慢。

     

    既然我们是沿着到达指定方格的路径来计算 G 值,那么计算出该方格的 G 值的方法就是找出其父亲的 G 值,然后按父亲是直线方向还是斜线方向加上 10 或 14 。随着我们离开起点而得到更多的方格,这个方法会变得更加明朗。

     

    有很多方法可以估算 H 值。这里我们使用 Manhattan 方法,计算从当前方格横向或纵向移动到达目标所经过的方格数,忽略对角移动,然后把总数乘以 10 。之所以叫做 Manhattan 方法,是因为这很像统计从一个地点到另一个地点所穿过的街区数,而你不能斜向穿过街区。重要的是,计算 H 是,要忽略路径中的障碍物。这是对剩余距离的估算值,而不是实际值,因此才称为试探法。

     

    把 G 和 H 相加便得到 F 。我们第一步的结果如下图所示。每个方格都标上了 F , G , H 的值,就像起点右边的方格那样,左上角是 F ,左下角是 G ,右下角是 H 。

    image003.jpg

    图 3

    好,现在让我们看看其中的一些方格。在标有字母的方格, G = 10 。这是因为水平方向从起点到那里只有一个方格的距离。与起点直接相邻的上方,下方,左方的方格的 G 值都是 10 ,对角线的方格 G 值都是 14 。

     

    H 值通过估算起点于终点 ( 红色方格 ) 的 Manhattan 距离得到,仅作横向和纵向移动,并且忽略沿途的墙壁。使用这种方式,起点右边的方格到终点有 3 个方格的距离,因此 H = 30 。这个方格上方的方格到终点有 4 个方格的距离 ( 注意只计算横向和纵向距离 ) ,因此 H = 40 。对于其他的方格,你可以用同样的方法知道 H 值是如何得来的。

     

    每个方格的 F 值,再说一次,直接把 G 值和 H 值相加就可以了。

     

    继续搜索(Continuing the Search)

    为了继续搜索,我们从 open list 中选择 F 值最小的 ( 方格 ) 节点,然后对所选择的方格作如下操作:

    4.       把它从 open list 里取出,放到 close list 中。

    5.       检查所有与它相邻的方格,忽略其中在 close list 中或是不可走 (unwalkable) 的方格 ( 比如墙,水,或是其他非法地形 ) ,如果方格不在open lsit 中,则把它们加入到 open list 中。

    把我们选定的方格设置为这些新加入的方格的父亲。

    6.       如果某个相邻的方格已经在 open list 中,则检查这条路径是否更优,也就是说经由当前方格 ( 我们选中的方格 ) 到达那个方格是否具有更小的 G 值。如果没有,不做任何操作。

    相反,如果 G 值更小,则把那个方格的父亲设为当前方格 ( 我们选中的方格 ) ,然后重新计算那个方格的 F 值和 G 值。如果你还是很混淆,请参考下图。

    image004.jpg

    图 4

    Ok ,让我们看看它是怎么工作的。在我们最初的 9 个方格中,还有 8 个在 open list 中,起点被放入了 close list 中。在这些方格中,起点右边的格子的 F 值 40 最小,因此我们选择这个方格作为下一个要处理的方格。它的外框用蓝线打亮。

     

    首先,我们把它从 open list 移到 close list 中 ( 这就是为什么用蓝线打亮的原因了 ) 。然后我们检查与它相邻的方格。它右边的方格是墙壁,我们忽略。它左边的方格是起点,在 close list 中,我们也忽略。其他 4 个相邻的方格均在 open list 中,我们需要检查经由这个方格到达那里的路径是否更好,使用 G 值来判定。让我们看看上面的方格。它现在的 G 值为 14 。如果我们经由当前方格到达那里, G 值将会为 20(其中 10 为到达当前方格的 G 值,此外还要加上从当前方格纵向移动到上面方格的 G 值 10) 。显然 20 比 14 大,因此这不是最优的路径。如果你看图你就会明白。直接从起点沿对角线移动到那个方格比先横向移动再纵向移动要好。

     

    当把 4 个已经在 open list 中的相邻方格都检查后,没有发现经由当前方格的更好路径,因此我们不做任何改变。现在我们已经检查了当前方格的所有相邻的方格,并也对他们作了处理,是时候选择下一个待处理的方格了。

     

    因此再次遍历我们的 open list ,现在它只有 7 个方格了,我们需要选择 F 值最小的那个。有趣的是,这次有两个方格的 F 值都 54 ,选哪个呢?没什么关系。从速度上考虑,选择最后加入 open list 的方格更快。这导致了在寻路过程中,当靠近目标时,优先使用新找到的方格的偏好。但是这并不重要。 ( 对相同数据的不同对待,导致两中版本的 A* 找到等长的不同路径 ) 。

     

    我们选择起点右下方的方格,如下图所示。

    image005.jpg

    图 5

     

    这次,当我们检查相邻的方格时,我们发现它右边的方格是墙,忽略之。上面的也一样。

    我们把墙下面的一格也忽略掉。为什么?因为如果不穿越墙角的话,你不能直接从当前方格移动到那个方格。你需要先往下走,然后再移动到那个方格,这样来绕过墙角。 ( 注意:穿越墙角的规则是可选的,依赖于你的节点是怎么放置的 )

     

    这样还剩下 5 个相邻的方格。当前方格下面的 2 个方格还没有加入 open list ,所以把它们加入,同时把当前方格设为他们的父亲。在剩下的3 个方格中,有 2 个已经在 close list 中 ( 一个是起点,一个是当前方格上面的方格,外框被加亮的 ) ,我们忽略它们。最后一个方格,也就是当前方格左边的方格,我们检查经由当前方格到达那里是否具有更小的 G 值。没有。因此我们准备从 open list 中选择下一个待处理的方格。

     

    不断重复这个过程,直到把终点也加入到了 open list 中,此时如下图所示。

    image006.jpg

    图 6

     

    注意,在起点下面 2 格的方格的父亲已经与前面不同了。之前它的 G 值是 28 并且指向它右上方的方格。现在它的 G 值为 20 ,并且指向它正上方的方格。这在寻路过程中的某处发生,使用新路径时 G 值经过检查并且变得更低,因此父节点被重新设置, G 和 F 值被重新计算。尽管这一变化在本例中并不重要,但是在很多场合中,这种变化会导致寻路结果的巨大变化。

     

    那么我们怎么样去确定实际路径呢?很简单,从终点开始,按着箭头向父节点移动,这样你就被带回到了起点,这就是你的路径。如下图所示。从起点 A 移动到终点 B 就是简单从路径上的一个方格的中心移动到另一个方格的中心,直至目标。就是这么简单!

    image007.jpg

    图 7

     

    A*算法总结(Summary of the A* Method)

    Ok ,现在你已经看完了整个的介绍,现在我们把所有步骤放在一起:

    1.         把起点加入 open list 。

    2.         重复如下过程:

    a.         遍历 open list ,查找 F 值最小的节点,把它作为当前要处理的节点。

    b.         把这个节点移到 close list 。

    c.         对当前方格的 8 个相邻方格的每一个方格?

    ◆     如果它是不可抵达的或者它在 close list 中,忽略它。否则,做如下操作。

    ◆     如果它不在 open list 中,把它加入 open list ,并且把当前方格设置为它的父亲,记录该方格的 F , G 和 H 值。

    ◆     如果它已经在 open list 中,检查这条路径 ( 即经由当前方格到达它那里 ) 是否更好,用 G 值作参考。更小的 G 值表示这是更好的路径。如果是这样,把它的父亲设置为当前方格,并重新计算它的 G 和 F 值。如果你的 open list 是按 F 值排序的话,改变后你可能需要重新排序。

    d.         停止,当你

    ◆     把终点加入到了 open list 中,此时路径已经找到了,或者

    ◆     查找终点失败,并且 open list 是空的,此时没有路径。

    3.         保存路径。从终点开始,每个方格沿着父节点移动直至起点,这就是你的路径。

     

     

    题外话(Small Rant)

    请原谅我的离题,当你在网上或论坛上看到各种关于 A* 算法的讨论时,你偶尔会发现一些 A* 的代码,实际上他们不是。要使用 A* ,你必须包含上面讨论的所有元素 ---- 尤其是 open list , close list 和路径代价 G , H 和 F 。也有很多其他的寻路算法,这些算法并不是 A* 算法, A* 被认为是最好的。在本文末尾引用的一些文章中 Bryan Stout 讨论了他们的一部分,包括他们的优缺点。在某些时候你可以二中择一,但你必须明白自己在做什么。 Ok ,不废话了。回到文章。

     

    实现的注解(Notes on Implemetation)

    现在你已经明白了基本方法,这里是你在写自己的程序是需要考虑的一些额外的东西。下面的材料引用了一些我用 C++ 和 Basic 写的程序,但是对其他语言同样有效。

     

    1.    维护 Open List :这是 A* 中最重要的部分。每次你访问 Open list ,你都要找出具有最小    F 值的方格。有几种做法可以做到这个。你可以随意保存路径元素,当你需要找到具     有最小 F 值的方格时,遍历整个 open list 。这个很简单,但对于很长的路径会很慢。这个方法可以通过维护一个排好序的表来改进,每次当你需要找到具有最小 F 值的方格时,仅取出表的第一项即可。我写程序时,这是我用的第一个方法。

          

           对于小地图,这可以很好的工作,但这不是最快的方案。追求速度的 A* 程序员使用了叫做二叉堆的东西,我的程序里也用了这个。以我的经验,这种方法在多数场合下会快 2—3 倍,对于更长的路径速度成几何级数增长 (10 倍甚至更快 ) 。如果你想更多的了解二叉堆,请阅读Using Binary Heaps in A* Pathfinding 。

    2.       其他单位:如果你碰巧很仔细的看了我的程序,你会注意到我完全忽略了其他单位。我的寻路者实际上可以互相穿越。这取决于游戏,也许可以,也许不可以。如果你想考虑其他单位,并想使他们移动时绕过彼此,我建议你的寻路程序忽略它们,再写一些新的程序来判断两个单位是否会发生碰撞。如果发生碰撞,你可以产生一个新的路径,或者是使用一些标准的运动法则(比如永远向右移动,等等)直至障碍物不在途中,然后产生一个新的路径。为什么在计算初始路径是不包括其他单位呢?因为其他单位是可以动的,当你到达的时候它们可能不在自己的位置上。这可以产生一些怪异的结果,一个单位突然转向来避免和一个已不存在的单位碰撞,在它的路径计算出来后和穿越它路径的那些单位碰撞了。

    在寻路代码中忽略其他单位,意味着你必须写另一份代码来处理碰撞。这是游戏的细节,所以我把解决方案留给你。本文末尾引用的 Bryan Stout's 的文章中的几种解决方案非常值得了解。

    3.       一些速度方面的提示:如果你在开发自己的 A* 程序或者是改编我写的程序,最后你会发现寻路占用了大量的 CPU 时间,尤其是当你有相当多的寻路者和一块很大的地图时。如果你阅读过网上的资料,你会发现就算是开发星际争霸,帝国时代的专家也是这样。如果你发现事情由于寻路而变慢了,这里有些主意很不错:

    ◆     使用小地图或者更少的寻路者。

    ◆     千万不要同时给多个寻路者寻路。取而代之的是把它们放入队列中,分散到几个游戏周期中。如果你的游戏以每秒 40 周期的速度运行,没人能察觉到。但是如果同时有大量的寻路者在寻路的话,他们会马上就发现游戏慢下来了。

    ◆     考虑在地图中使用更大的方格。这减少了寻路时需要搜索的方格数量。如果你是有雄心的话,你可以设计多套寻路方案,根据路径的长度而使用在不同场合。这也是专业人士的做法,对长路径使用大方格,当你接近目标时使用小方格。如果你对这个有兴趣,请看 Two-Tiered A* Pathfinding 。

    ◆     对于很长的路径,考虑使用路径点系统,或者可以预先计算路径并加入游戏中。

    ◆     预先处理你的地图,指出哪些区域是不可到达的。这些区域称为“孤岛”。实际上,他们可以是岛屿,或者是被墙壁等包围而不可到达的任意区域。 A* 的下限是,你告诉他搜寻通往哪些区域的路径时,他会搜索整个地图,直到所有可以抵达的方格都通过 open list 或 close list 得到了处理。这会浪费大量的 CPU 时间。这可以通过预先设定不可到达的区域来解决。在某种数组中记录这些信息,在寻路前检查它。在我的 Blitz 版程序中,我写了个地图预处理程序来完成这个。它可以提前识别寻路算法会忽略的死路径,这又进一步提高了速度。

    4.    不同的地形损耗:在这个教程和我的程序中,地形只有 2 种:可抵达的和不可抵达        的。但是如果你有些可抵达的地形,移动代价会更高些,沼泽,山丘,地牢的楼梯

           等都是可抵达的地形,但是移动代价比平地就要高。类似的,道路的移动代价就比        它周围的地形低。

    在你计算给定方格的 G 值时加上地形的代价就很容易解决了这个问题。简单的给这些方格加上一些额外的代价就可以了。 A* 算法用来查找代价最低的路径,应该很容易处理这些。在我的简单例子中,地形只有可达和不可达两种, A* 会搜寻最短和最直接的路径。但是在有地形代价的环境中,代价最低的的路径可能会很长。

    就像沿着公路绕过沼泽而不是直接穿越它。

    另一个需要考虑的是专家所谓的“ influence Mapping ”,就像上面描述的可变成本地形一样,你可以创建一个额外的计分系统,把它应用到寻路的 AI 中。假设你有这样一张地图,地图上由个通道穿过山丘,有大批的寻路者要通过这个通道,电脑每次产生一个通过那个通道的路径都会变得很拥挤。如果需要,你可以产生一个 influence map ,它惩罚那些会发生大屠杀的方格。这会让电脑选择更安全的路径,也可以帮助它避免因为路径短(当然也更危险)而持续把队伍或寻路者送往某一特定路径。

    5.    维护未探测的区域:你玩 PC 游戏的时候是否发现电脑总是能精确的选择路径,甚至地图都未被探测。对于游戏来说,寻路过于精确反而不真实。幸运的是,这个问题很容易修正。答案就是为每个玩家和电脑(每个玩家,不是每个单位 --- 那会浪费很多内存)创建一个独立的 knownWalkability 数组。每个数组包含了玩家已经探测的区域的信息,和假设是可到达的其他区域,直到被证实。使用这种方法,单位会在路的死端徘徊,并会做出错误的选择,直到在它周围找到了路径。地图一旦被探测了,寻路又向平常一样工作。

    6.    平滑路径: A* 自动给你花费最小的,最短的路径,但它不会自动给你最平滑的路径。看看我们的例子所找到的路径(图 7 )。在这条路径上,第一步在起点的右下方,如果第一步在起点的正下方是不是路径会更平滑呢?

           有几个方法解决这个问题。在你计算路径时,你可以惩罚那些改变方向的方格,把它的 G 值增加一个额外的开销。另一种选择是,你可以遍历你生成的路径,查找那些用相邻的方格替代会使路径更平滑的地方。要了解更多,请看 Toward More Realistic Pathfinding 。

    7.    非方形搜索区域:在我们的例子中,我们使用都是 2D 的方形的区域。你可以使用不规则的区域。想想冒险游戏中的那些国家,你可以设计一个像那样的寻路关卡。你需要建立一张表格来保存国家相邻关系,以及从一个国家移动到另一个国家的 G 值。你还需要一个方法了估算 H 值。其他的都可以向上面的例子一样处理。当你向 open list 添加新项时,不是使用相邻的方格,而是查看表里相邻的国家。

    类似的,你可以为一张固定地形的地图的路径建立路径点系统。路径点通常是道路或地牢通道的转折点。作为游戏设计者,你可以预先设定路径点。如果两个路径点的连线没有障碍物的话它们被视为相邻的。在冒险游戏的例子中,你可以保存这些相邻信息在某种表中,当 open list 增加新项时使用。然后记录 G 值(可能用两个结点间的直线距离)和 H 值(可能使用从节点到目标的直线距离)。其它的都想往常一样处理。

    进一步阅读(Further Reading)

    Ok ,现在你已经对 A* 有了个基本的了解,同时也认识了一些高级的主题。我强烈建议你看看我的代码,压缩包里包含了 2 个版本的实现,一个是 C++ ,另一个是 Blitz Basic 。 2 个版本都有注释,你以该可以很容易就看懂。下面是链接:

    Sample Code: A* Pathfinder (2D) Version 1.71 。

     

    如果你不会使用 C++ 或是 BlitzBasic ,在 C++ 版本下你可以找到两个 exe 文件。 BlitzBasic 版本必须去网站 Blitz Basic 下载 BlitzBasic 3D 的免费 Demo 才能运行。 在这里 here 你可以看到一个 Ben O'Neill 的 A* 在线验证实例。

     

    你应该阅读下面这几个站点的文章。在你读完本教程后你可以更容易理解他们。

    Amit's A* Pages : Amit Patel 的这篇文章被广泛引用,但是如果你没有阅读本教程的话,你可能会感到很迷惑。尤其是你可以看到 Amit Patel自己的一些想法。

    Smart Moves: Intelligent Path Finding : Bryan Stout 的这篇需要去 Gamasutra.com 注册才能阅读。 Bryan 用 Delphi 写的程序帮助我学习了A* ,同时给了我一些我的程序中的一些灵感。他也阐述了 A* 的其他选择。

    Terrain Analysis : Dave Pottinger 一篇非常高阶的,有吸引力的文章。他是 Ensemble Studios 的一名专家。这个家伙调整了游戏帝国时代和王者时代。不要期望能够读懂这里的每一样东西,但是这是一篇能给你一些不错的主意的很有吸引力的文章。它讨论了包 mip-mapping ,

    influence mapping ,和其他高阶 AI 寻路主题。他的 flood filling 给了我在处理死路径 ”dead ends” 和孤岛 ”island” 时的灵感。这包含在我的 Blitz版本的程序里。

     

    下面的一些站点也值得去看看:

    ·                     aiGuru: Pathfinding

    ·                     Game AI Resource: Pathfinding

    ·                     GameDev.net: Pathfinding 


    谢谢。

    展开全文
  • A星寻路算法cpp文件

    2020-12-02 18:06:47
    A星寻路算法cpp文件,包含了A星寻路的算法流程以及地图块结构,整个算法流程
  • A星算法理解

    2020-04-23 23:01:33
    A星算法理解 1.选择A星算法的原因 为了进行路径规划算法是不可回避的:启发式搜索算法是比较常规的一类算法就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,再从这个位置进行搜索直到目标。这样...

    A星算法理解

    1.选择A星算法的原因

    为了进行路径规划算法是不可回避的:启发式搜索算法是比较常规的一类算法就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,再从这个位置进行搜索直到目标。这样可以省略大量无谓的搜索路径,提高了效率。在启发式搜索中,对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。启发中的估价是用估价函数表示的,如:f(n) = g(n) + h(n) 。g(n)为起点到当前位置的实际路径长度,h(n)为所在位置到终点的最佳路径的估计距离。前面说每次会优先向终点方向进行移动,就是因为估价函数所导致的。h(n)=0时,意味着此时是盲目搜索,当h(n)越复杂,即约束的条件越多,耗费的时间就越多,而减少约束条件,则可能得到的并不是最优路线。在A算法中,估价函数为f(n)=g(n)+h*(n)。这里面的h*(n)的附加条件为h*(n)<=h‘(n),h’(n)为n到目标的直线最短距离,也就说A*算法中挑选的启发函数是最优的,也正是如此,所找到的路径是最短路径。

    2.启发函数的选择问题

    有时候经过简单的对比,很容易得出曼哈顿距离作为启发函数,搜索效率最高,并得出曼哈顿距离最好的结论。可是在实际情况下,我们不仅要考虑搜索效率,也要考虑最优性,所以大多情况下选择対角距离作为启发函数。

    3.算法流程图

    在这里插入图片描述

    4.算法实现步骤

    1. 启发式函数
    
        double Manhattan_dist,Euclidean_dist,Diagonal_dist;
        Eigen::Vector3i diff=node2->index-node1->index;
        double dx,dy,dz;
        dx=abs(diff(0));
        dy=abs(diff(1));
        dz=abs(diff(2));
        Manhattan_dist=dx+dy+dz;
        Euclidean_dist=sqrt(diff.dot(diff));
        float dmin = min(dx, min(dy, dz));
        float dmax = max(dx, max(dy, dz));
        float dmid = dx + dy + dz - dmin - dmax;
        Diagonal_dist=(1.732 - 1.414) * dmin + (1.414 - 1) * dmid +  dmax;
        // tie breaker
        hue=Diagonal_dist*1.00001;
        return Euclidean_dist;
    
    
    1. 将起始节点放入OPEN表里
    startPtr -> gScore = 0;
        startPtr -> fScore = getHeu(startPtr,endPtr);
        //STEP 1: finish the AstarPathFinder::getHeu , which is the heuristic function
        startPtr -> id = 1; 
        startPtr -> coord = start_pt;
        openSet.insert( make_pair(startPtr -> fScore, startPtr) );
    
    1. 当主循环不为空时
    while ( !openSet.empty() )
    
    1. 将代价值最小的点从open表转移到close表中,并将原表中的点删除
    //        openSet.begin()->second->cameFrom=currentPtr;
            currentPtr=openSet.begin()->second;//acending order
            //move it to closeset at once
            currentPtr->id=-1;
    
    //        closeSet.insert(make_pair(openSet.begin()->first,openSet.begin()->second));
            openSet.erase(openSet.begin());
            GridNodeMap[currentPtr->index[0]][currentPtr->index[1]]
                    [currentPtr->index[2]]=currentPtr;
    
    
    1. 如果当前点是目标点,路径成功结束。
    // if the current node is the goal 
            if( currentPtr->index == goalIdx ){
                ros::Time time_2 = ros::Time::now();
                terminatePtr = currentPtr;
                ROS_WARN("[A*]{sucess}  Time in A*  is %f ms, path cost if %f m", (time_2 - time_1).toSec() * 1000.0, currentPtr->gScore * resolution );            
                return;
            }
            //get the succetion
    
    1. 对扩展节点进行扩展子节点
     *        
            */         
            for(int i = 0; i < (int)neighborPtrSets.size(); i++){
                /*
                *
                *
                Judge if the neigbors have been expanded
                please write your code below
                
                IMPORTANT NOTE!!!
                neighborPtrSets[i]->id = -1 : expanded, equal to this node is in close set
                neighborPtrSets[i]->id = 1 : unexpanded, equal to this node is in open set
                *        
                */
                neighborPtr=neighborPtrSets[i];
    
    
                if(neighborPtr -> id == 0){ //discover a new node, which is not in the closed set and open set
                    /*
                    *
                    *
                    STEP 6:  As for a new node, do what you need do ,and then put neighbor in open set and record it
                    please write your code below
                    *        
                    */
                    neighborPtr -> gScore=edgeCostSets[i];
                    neighborPtr -> fScore = getHeu(neighborPtr,endPtr)+edgeCostSets[i];
                    neighborPtr ->id=1;//open
                    neighborPtr->cameFrom=currentPtr;
                    openSet.insert( make_pair(neighborPtr -> fScore, neighborPtr) );
                    //update map
                    GridNodeMap[neighborPtr->index[0]][neighborPtr->index[1]]
                            [neighborPtr->index[2]]=neighborPtr;
                    continue;
                }
                else if(neighborPtr -> id ==1){ //this node is in open set and need to judge if it needs to update, the "0" should be deleted when you are coding
                    /*
                    *
                    *
                    STEP 7:  As for a node in open set, update it , maintain the openset ,and then put neighbor in open set and record it
                    please write your code below
                    *        
                    */
                    if(neighborPtr->gScore>edgeCostSets[i])
                        neighborPtr->gScore=edgeCostSets[i];
                    neighborPtr -> fScore = getHeu(neighborPtr,endPtr)+neighborPtr->gScore;
    
                    continue;
                }
                else if(neighborPtr -> id ==-1){//this node is in closed set: it is impossible that node in closeset will be suceession
                    /*
                    *
                    please write your code below
                    *        
                    */
    //                ROS_ERROR("NOOOO");
                    continue;
                }
            }
    
        }
    
    1. 由当前点获取路径上的所有点
    while(terminatePtr!=nullptr)
        {
            gridPath.push_back(terminatePtr);
            terminatePtr=terminatePtr->cameFrom;
            if(gridPath.size()>100)
            {
                ROS_ERROR("dead loop!!");
                break;
            }
        }
        for (auto ptr: gridPath)
            path.push_back(ptr->coord);
            
        reverse(path.begin(),path.end());
    
        return path;
    

    一个具有注脚的文本。1


    1. 注脚的解释
      小白一枚 ↩︎

    展开全文
  • A星算法说明

    2021-03-05 11:40:42
    文章目录前言原理说明如何构造h(n)h(n)h(n)一、欧氏距离二、曼哈顿距离三、其他关于g(n)g(n)g(n)路况设置如何实现完整的流程核心代码a_star.ha_star.cppmap_matrix.hmap_matrix.cpp代码使用示例GUI程序下载链接GUI...
    A*算法说明

    前言

      因为最近要写一个毕业设计,有用到自动寻路的功能,因为我要在一个机器里跑算法然后控制机器人自动按照路线到达目的地,所以用Python等解释型语言或Unity等游戏引擎写这个算法都不太合适,我使用的机器要尽可能不在里面安装大型的库。所以我就用C++实现了一个A*算法。因为实现了之后觉得这个算法比较有意思,就又写了一个GUI程序,可以选择显示过程,即以可视化查看算法寻路的过程。
      我写的A*算法在能找到最优路线的前提下,支持斜方位移动(可以选择是否允许斜方位移动),支持设置道路拥堵情况(默认所有位置路况为1,如果设置大于1,则表示拥堵,数值越大则越拥堵,如果设置小于1,则表示比默认路况更为畅通,数值越小则越通畅,如果设置为0表示异常畅通,即通过此道路代价为0,如果设置为负数表示++\infty,即无法通行),支持选择是否使用优先队列,支持读取和保存地图,在GUI程序里支持显示寻找路线的动画。

    原理说明

      A*可以认为是添加了启发式函数的Dijkstra算法,在Dijkstra算法的基础上,构造一个函数h(n)h(n),n为当前扩展结点,h(n)h(n)返回结点n到终点的开销估计。然后建立函数f(n)=g(n)+h(n)f(n)=g(n)+h(n),其中g(n)g(n)为从起点到结点n已经使用了的代价,所以f(n)f(n)可以理解为是“从起点出发经过结点n再到终点的代价估计”
      关于h(n)h(n)的构造返回值的问题会对A*算法造成影响:

      如果构造h(n)0h(n) \equiv 0,那么该A*算法就已经退化为了Dijkstra算法,一定能解得最优解但是运行效率最低。
      如果构造h(n)h(n)h(n) \equiv h^*(n),则该A*算法不仅能够保证一定能解得最优解,而且运行效率在所有能保证解得最优解的A*算法中是最高的。其中h(n)h^*(n)表示结点n到终点的实际代价。
      如果构造的h(n)h(n)对所有的n有h(n)h(n)h(n) \leq h^*(n),则该A*算法能保证一定能得到最优解,但是效率略低于上述h(n)h(n)h(n) \equiv h^*(n)的情况。
      如果构造的h(n)h(n)存在n使得h(n)>h(n)h(n)>h^*(n),则该A*算法不一定能得到最优解(当然运气好的时候也有可能会解得最优解,但是不能保证)。

      所以,我们应该构造满足对所有的n有h(n)h(n)h(n) \leq h^*(n)h(n)h(n)。虽然h(n)h(n)h(n) \equiv h^*(n)效果最好,但是面对复杂的地图,这种启发式函数可欲而不可求(当然,h(n)h(n)函数必须要是复杂度极低的,不能说我为了估计结点n到终点的代价而真的去用A*算法本身以n为起点跑一遍然后得到实际最小代价,这样就没有意义了,引进h(n)h(n)就是为了“剪支”的,如果在h(n)h(n)里对n展开用A*计算,那剪支的意义何在?都已经展开了)

      构造好f(n)f(n)后,构造一个优先队列(如果对效率要求不高,直接用普通的队列也可以),队列里保存活结点,每次出队的元素为扩展结点,扩展结点发散到的新结点将入队到队列。算法开始时把起点加入队列,循环直到队列为空,即可找到最优路线。如果采用优先队列,每次出队的元素为f(n)f(n)值最小的结点,这样会大大减小搜索范围。在下面的搜索过程图示可以直观地感受到使用优先队列和普通队列的区别。

    如何构造h(n)h(n)

      要构造h(n)h(n)首先要定义任意两个结点的距离,不能像Dijkstra那样用没有定义任意两点距离的抽象的图(Dijkstra算法用的图最多邻接矩阵带有权值,但即使是这样,也只是在“能直接到达的两个点之间”定义了距离,不能直接到达而是需要中转的两个点之间并没有定义距离)
      为了简化,使用格子地图,则h(n)h(n)可以构造为:

    一、欧氏距离

      最简单的就是直接用欧式距离估计结点n到终点的距离,这样对于格子地图必定满足h(n)h(n)h(n) \leq h^*(n),首选。

    二、曼哈顿距离

      对于规定不能斜着走的格子地图,用曼哈顿距离(两点X差的绝对值+Y差的绝对值)也是可以的。但是如果地图可以斜着走,就不能保证h(n)h(n)h(n) \leq h^*(n)了,不过可以采用除以2\sqrt{2}的方式保证h(n)h(n)h(n) \leq h^*(n)必定满足。

    三、其他

      其他任何满足h(n)h(n)h(n) \leq h^*(n)的距离都可以选用。

    关于g(n)g(n)

      把g(n)g(n)作为一个属性(比如我用cost表示这个属性)绑定在结点n里即可,寻路算法开始前设置所有的结点的cost设为++\infty(实际编程里用负数表示++\infty,常用-1表示)。在寻路开始时,先把起点的cost设为0,然后从起点开始发散的过程中,如果是直着(上、下、左、右)从格子A到下一个格子B,则到达的那个格子B的cost设置为A的cost+1cost+1,如果是斜着(左上方、左下方、右上方、右下方)从格子A到下一个格子B,则到达的那个格子B的cost设置为A的cost+2cost+\sqrt{2}即可完成支持直走和斜走的cost的迭代,函数g(n)g(n)只需要返回n的cost即可。

    路况设置如何实现

      就是上述的cost+1改成cost+1×conditioncost+1 \times condition,把上述的cost+2cost+\sqrt{2}改成cost+2×conditioncost+\sqrt{2} \times condition,其中condition是要到达的位置的路况。
      然后要修改h(n)h(n),在原先返回的h(n)h(n)的基础上乘整个地图的最小的condition,这样就能保证对于任何一个n仍然满足h(n)h(n)h(n) \leq h^*(n),这样即可在设置不同路况的情况下还能保证能解得最优解。

    完整的流程

      “伪代码”如下:

    [准备格子地图,设置h(n)并且f(n)=g(n)+h(n)]
    |
    |算法开始
    v
    [输入起点b和终点e,设置当前已经得到的临时最优解对应的代价M=正无穷]
    |
    v
    [构造一个优先队列Q元素为结点(Node*),结点拥有属性double cost、Node *prior和double condition,每次出队的结点n为f(n)值最小的]
    |
    |初始化所有结点的cost为正无穷(代码实现起来是-1),prior为NULL,condition是路况
    |
    v
    [b入队到Q]
    |
    |<--------------------------------------
    |                                     真|
    v            真                         |        假
    [Q不为空?] -------->[Q出队一个元素i]-->[f(i)>=M?]------->[i往8个方向发散,记8个方向在数组里t[8]; j=0]
    |    ^                                                                        |
    |    |                                      假                                 v                ++j
    |    ---------------------------------------------------------------------- [j<8?] <-------------------------
    |                                                                             |                             |
    |假                                                                            |真                           ^
    |                                                                             v                        假   |
    |      [i->cost+d(i, t[j]) < t[j]->cost ?   (d(i, t[j])如果i和t[j]是直着的是1,如果i和t[j]是斜着的是根号2)]-->---|
    |                                                                            |真                            |
    |                                                                            v                              ^
    |                          [设置t[j]->cost = i->cost+d(i, t[j])*t[j]->condition; 设置t[j]->prior = i]        |
    |                                                     |                                                     |
    |                                                     v                 假                                  |
    |          [t[j]是e?  (如果使用的是拷贝的地图数据则考虑t[j]和e坐标是否相同)] ------>[t[j]入队到Q]------------>------
    |                                          |真                                                              |
    |                                          v                                                                ^
    |                                 [设置M = t[j]->cost]----------------->-------------------------------------
    |
    |                                                            ----------------------------
    |                                                            |                           |
    v                 真                                         v                           |
    [e->prior!=NULL?]------->[构造一个栈R,设置结点指针i=e]----->[i==NULL?]------->[i入栈到R; i=i->prior]
    |                                                           真|      假
    |假                                                           |
    v                                                             v
    [无解,b和e之间是不连通的]                         [返回R,R的出栈顺序即为从b到e的路径]
    

      上面的“伪代码”乱得我自己都不想看。。。下面来个Flowchart流程图表述流程吧:

    Created with Raphaël 2.2.0准备格子地图,设置h(n)并且f(n)=g(n)+h(n)算法开始设置当前已经得到的临时最优解对应的代价M=正无穷输入起点b和终点e构造一个优先队列Q元素为结点(Node*),结点拥有属性:double cost(当前已用代价)、Node *prior(路径的上一个位置)、double condition(路况),每次出队的结点n为f(n)值最小的初始化所有结点的cost为正无穷(代码实现起来是-1),prior为NULLb入队到QQ不为空Q出队一个元素if(i)<Mi往8个方向发散,记8个方向在数组里t[8]。d(x, y)表示相邻两点的距离,直着为1,斜着为根号2; j=0j<8i->cost+d(i, t[j]) < t[j]->cost设置t[j]->cost = i->cost+d(i, t[j])*t[j]->condition; 设置t[j]->prior = it[j]是e设置M = t[j]->cost++je->prior!=NULL构造一个栈R,设置结点指针i=ei==NULL返回R,R的出栈顺序即为从b到e的路径结束i入栈到Ri=i->prior无解,b和e之间是不连通的t[j]入队到Qyesnoyesnoyesnoyesnoyesnoyesnoyesno

    搜索过程图示

      下面展示搜索过程动画的工具是我在写完A*算法后觉得挺有意思然后进一步写的一个GUI程序,在后面的GUI程序下载链接可以下载。

    允许斜走,使用优先队列

    允许斜走优先队列

    禁止斜走,使用优先队列

    禁止斜走优先队列

    允许斜走,使用普通队列

    允许斜走普通队列

    禁止斜走,使用普通队列

    禁止斜走普通队列

      可以看到,用优先队列会减少很多不必要的搜索区域。我是先录屏,然后上面两张图片是用ps转换为gif的,下面两张因为时间比较长,用ps储存为web格式的时候内存爆了,所以下面两张是用格式工厂转换的,画质极差,将就着看吧。

    核心代码

      由于代码较长,不能折叠显示,这里只贴出部分代码,完整代码见:
    https://github.com/Eyre-Turing/a_star

    结点展开的循环

    //isRunnable是一个bool变量,如果要中止寻路,则可以通过在其他的线程把isRunnable设置为false实现。
    //aliveNodeP是一个优先队列
    //handleAliveNodeCallBack是一个回调函数,用于给GUI程序等提供显示路径搜索过程使用。
    //MapPos是一个结构体,保存地图的一个点的坐标(r, c)、已经消耗的代价(cost)以及代价估计(lowerBound)
    //searchOne是把一个结点往四周展开(如果支持斜着走就是八方向展开,否则是四方向展开)
    //matrix是地图,其get方法是获取一个结点指针(MapNode*),MapNode的isInAliveNodes属性保存该结点的坐标(MapPos)是否在aliveNodeP里存在,目的是去除重复展开。
    while(isRunnable && !aliveNodeP.empty())
    {
        MapPos handleAliveNode = aliveNodeP.top();
        aliveNodeP.pop();
    
        if(handleAliveNodeCallBack)
        {
            handleAliveNodeCallBack(this, handleAliveNode);
        }
        searchOne(handleAliveNode.r, handleAliveNode.c, handleAliveNode.lowerBound);
    
        matrix->get(handleAliveNode.r, handleAliveNode.c)->isInAliveNodes = false;
    }
    while(!aliveNodeP.empty())
    {
        MapPos handleAliveNode = aliveNodeP.top();
        aliveNodeP.pop();
        matrix->get(handleAliveNode.r, handleAliveNode.c)->isInAliveNodes = false;
    }
    

    代价估计函数f(n)f(n)

    /*
     * 从起点经过当前点[r][c],再到终点,路径长度的一个下界
     * 如果这个下界小于当前已经得到的解,认为是有希望比当前已经得到的解更优的
     * 如果这个下界大于或等于已经得到的解,则这条路不必再展开搜索了
     * -1认为是正无穷(或者是负数认为是正无穷)
     */
    double AStar::lowerBoundFunction(int r, int c) const
    {
    //minCondition是地图里最小的路况,如果最小路况为正无穷(代码表示为负数),就返回正无穷(代码表示为-1)。
    //endR和endC为终点的位置坐标,endR为Y值,endC为X值。
        if(minCondition < 0)
        {
            return -1;
        }
        if(isObliqueEnable)
        {
            return matrix->get(r, c)->cost+sqrt(pow(r-endR, 2)+pow(c-endC, 2))*minCondition;    //下界为:已走路程+最小路况下当前点到终点的欧氏距离
        }
        else
        {
            return matrix->get(r, c)->cost+(fabs(r-endR)+fabs(c-endC))*minCondition;            //下界为:已走路程+最小路况下当前点到终点的曼哈顿距离
        }
    }
    

    GUI程序下载链接

    Windows:  http://eyre-turing.top/project/get_data/a_star.exe
    Linux x64: http://eyre-turing.top/project/get_data/a_star

    给两幅测试地图

    一、点我下载简单迷宫

      效果如下:
    简单迷宫

    二、点我下载复杂迷宫

      效果如下:
    复杂地图

    该地图我没有设置起点和终点位置,你可以自己随便设置。

    GUI程序使用说明

      宽度高度编辑框设置地图的大小,尺寸设置每个格子的边长占多少个像素。修改了这些参数后要点击确认修改才会生效。
      勾选编辑模式即可编辑墙壁以及路况,编辑模式下在地图空白处点击左键即可添加墙,在墙处点击左键即可移除墙(地图界面中黑色的是墙)。编辑模式下,对空白处右键即可设置路况,右键后选中的格子会有黄色边框,黄色边框出现后,在路况编辑框填入数字即可调整选中格子的路况,路况值越大表示该位置越拥堵。
      点击设置起点后即可在地图上标记起点位置,起点是绿色格子;点击设置终点后即可在地图上标记终点位置,终点是红色格子。
      勾选显示网格后会画出地图所有格子的边框。
      勾选允许斜走即可八方向发散搜索路线,勾选斜可贴墙即可斜走的情况下贴着墙走。

      点击计算路线即可开始运行A*算法搜索路径,点击清理路线即可消除计算出来的路线,在开始寻路的时候,清理路线按钮会变成计算中止按钮,点击即可中止寻路。
      勾选画出路线即可在搜索出路径后在地图上画出来。
      勾选优先队列即使用优先队列来保存活结点队列。
      勾选显示过程即可在计算路线时动画显示出搜索路线的过程,勾选后会在下方显示一个文本编辑框,该编辑框可以设置动画显示的速度。
      菜单栏的文件可以展开以执行读取地图和保存地图的操作。

    展开全文
  • A星算法寻找最短路径

    千次阅读 2017-12-29 11:32:37
    一个非常基础的算法就是A星算法。 我需要在一副图像中寻找两点之间的最短路径,而角色只能上下左右移动。 注意角色被规定的移动方式不同,那么我们设计的代价函数需要调整。 图像中的灰度为0的像素认为是障碍物。...
  • A星算法(自动寻路)含文档说明 代码详解
  • AStar算法,A星算法

    2011-01-31 22:38:00
    包含A星算法 ....... .xxx... ...x.x. ...x.x. .....x. .....x. .....x.
  • -----------------------------精品文档------------------------------------- 实验三A*算法求解8数码问题实验 一 实验目的 熟悉和掌握启发式搜索的定义估价函数和算法过程并利用A*算法求解N数码难题理解求解流程和...
  • 一个详细描述A星算法过程的C#例子,有源代码。 这个例子不追求运算速度,追求的是对算法逻辑的描述。 代码中运算过程是中文的,面向对象的。
  • 大师写就,堪称经典的A*算法。并且开源,易于移植。用MFC写的框架,没有多余部分,多重显示方式,地图编辑功能。
  • 路径规划: a star, A星算法详解

    千次阅读 2018-02-26 18:09:01
    如此好贴,不能不转!...如果侵害到您的权益,请联系我,我将删除...Amit's A star Page中译文 译序这篇文章很适合A*算法的初学者,可惜网上没找到翻译版的。本着好东西不敢独享的想法,也为了锻炼一下英文,本人译了...
  • A星寻路算法介绍

    2015-07-17 14:03:03
    如果是的话,请看这篇教程,我们会展示如何使用A星寻路算法来实现它! 在网上已经有很多篇关于A星寻路算法的文章,但是大部分都是提供给已经了解基本原理的高级开发者的。 本篇教程将从最基本的原理讲起。我们...
  • 寻路算法有深度优先搜索(DFS),广度优先搜索(BFS),A星算法等,而A星算法是一种具备启发性策略的算法,效率是几种算法中最高的,因此也成为游戏中最常用的寻路算法。 直入正题: 在游戏设计中,地图可以划分为若干...
  • 在这里我将用大量的图片一步一步地列出A星算法的寻路过程。A星算法对于大地图的效率不高,大地图的寻路算法可以尝试用导航网络处理,如果想了解大地图的算法,可以来这里看下http://www.zhihu.com/question/20298134...
  • 算法复习】寻路算法1 - A星 A star

    千次阅读 2013-10-27 18:51:48
    注意到,本文对A星算法的简介是基于wiki和boost中的BGL库,这是因为:1、wiki的条件目是经过世界上成千上万人审阅,准确性可有保证,不像一些个人博客那样错漏(文后参考资料部分将对网上著名的文章评述);...
  • 一、A星搜索 他就是一种启发性的算法,根据现在到达这个位置的步数及之后的“估计步数”,即f=g+h,f是整个从起点到终点的代价,g是...(以上的部分只能说是我对A星算法较为浅的理解,只能算是初探吧,有不足之处欢迎
  • cocos2d-x游戏实例(5)-A星算法(1)

    万次阅读 2012-02-26 22:14:08
    继续上一篇地图上的处理,不过和本篇相比,我们之前的四篇,可都算是“热身准备”了,因为我们要研究一个算法并把它加入到我们的游戏中,这种算法在rpg,以及现在比较火爆的“乱斗”类(参考战斗之心battle heart)...
  • 接上一篇的博文,这篇我会把A星算法的程序流程图给大家贴出来还有Cocos2d-x的源码。原理在第一篇已经讲的很清楚了,最近特别忙所以就不逐行的讲解代码了,对比着流程图慢慢看就行了。我建议把流程图打印出来,因为...
  • 《魔塔之拯救白娘子》流程分析2: ⑤游戏界面鼠标点击判断以及自动寻路: 自动寻路的效果如下: 源码如下: Sub 游戏界面鼠标点击判断() Dim map(12, 12) As Integer Dim j As Integer Dim k As Integer Dim a As ...
  • 题目:假设我们有一个7×5大小的迷宫,如下所示,绿色格子表示起点,红色的格子表示终点,中间的3个深灰色格子表示障碍物。请找到一条从起点到终点最短的路径。 解题思路:       ...
  • Hybrid A* 算法基本流程

    千次阅读 2020-03-15 15:21:59
    openset = PriorityQueue() // pop out node with least totoal cost (heuriscost + trajcost) openset.push(start, 0) closedset = {} trajcost[start] = 0 while not openset.empty(): current = openset.t...
  • A*算法

    2018-08-10 12:39:14
    A星算法是最优的寻路算法,常用于游戏中寻找地图上2点之间最低耗价的路径,当然,没一点有各种属性,例如,点有横纵坐标,点有地形属性,是属于沼泽,还是沙丘,又或者是平地, 游戏中人物经过此点的耗价肯定是不...
  • A*算法图解

    千次阅读 2017-02-20 13:46:37
    记得好象刚知道游戏开发这一行的时候老师就提到过A星算法,当时自己基础还不行,也就没有去看这方面的资料,前几天找了一些资料,研究了一天,觉的现在网上介绍A星算法的资料都讲的不够详细(因为我下的那个资料基本算是最...
  • 角色寻路之A*算法

    2019-01-04 20:25:28
    A星算法作为启发式搜索算法的一种,其相对于盲目型搜索算法(如广度优先搜索算法和深度优先搜索算法)和半启发式搜索算法(如 Dijkstra算法)来说,不仅有着更强的针对性,而且其效率也要高于以上几种算法。...
  • 3a星算法实验报告.pdf

    2020-02-25 21:46:09
    人工智能实验报告 实验二 A* 算法实验 I 一实验目的 熟悉和掌握启发式搜索的定义估价函数和算法过程并利用 A* 算法求解 N 数码难题理解求解流程和搜索顺序 二实验原理 A* 算法是一种启发式搜索算法其特点在于对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,105
精华内容 3,642
关键字:

a星算法流程图