[小明学算法]3.启发式搜索算法----A*算法之我见

1.算法介绍

a*算法是一种寻路算法,类似于图的广度优先遍历搜索.

2.基本概念

设计先两个集合CloseList和OpenList,CloseList表示已经走过的节点,OpenList中的节点表示所有我们可以选择的下一步节点.

3.计算步骤:

1.将起点设为当前节点,并创建OpenList和CloseList.

2.将当前节点从OpenList中删除,并加入到CloseList中.

3.遍历当前节点的可到达节点,不包括CloseList中的节点,记录为AroundList,

4.然后对每个AroundList中的节点进行估值,f(x)=g(x)+h(x)

　　①.计算g(x).g(x)是消耗记录值,表示走过的路程所需要消耗的值,为当前节点的g值加上与当前节点的距离值.同时需将估值节点的加入OpenList并将估值节点的父节点设为当前节点.

　　　　在计算g(x),需要注意若此节点已存在于OpenList中,而且新g(x)小于原g(x),则更改g(x)的值,并更改当此节点的父节点为当前节点,否则不做修改.

　　②h(x)其中,g(x)表示估值算法,计算其与目标位置距离的估值.

　　　　h(x)就是启发式搜索的估值函数,此函数写的越好,算法的效率就越高

5.若未到达目标节点,执行6,若到达目标节点,执行7

6.选择OpenList当中f(x)最小的点,设为当前节点,重复以上步骤2,3,4,5..

7.通过当前节点的父节点属性一直往上遍历,则得到目标路径节点的倒序排列.

 

4.代码实现

using System.Collections.Generic;

namespace 动态规划
{
    internal class Program
    {
        readonly List<Node> OpenList = new List<Node>();
        readonly List<Node> CloseList = new List<Node>();

        List<Node> FindWayByAStart(Node startNode, Node endNode)
        {
            //1.将当前节点加入到CloseList中,并从OpenList中删除
            CloseList.Add(startNode);
            if (OpenList.Contains(startNode))
                OpenList.Remove(startNode);
            //2.寻找当前节点所有可以到达的节点
            //且可到达的节点并不再CloseList中,则加入AroundList
            //TODO
            var aroundList = new List<Node>();

            //3.对AroundList中的每个节点计算f(x)=g(x)+h(x)的值
            foreach (Node curNode in aroundList)
            {      
                if (!OpenList.Contains(curNode))
                { 
                    //如果此节点不在OpenList中,正常估值
                    //将此节点加入到OpenList中,并将其父节点设为当前节点
                    curNode.G = GetGValue(curNode, startNode) + startNode.G;
                    curNode.H = GetHValue(curNode, endNode);
                    curNode.Parent = startNode;
                    OpenList.Add(curNode);
                }
                else
                {  
                    //此节点在OpenList中
                    //若此节点的新估值g(x)小于之前的g(x),则更改g(x)的值,并重新赋值父节点
                    int newg = GetGValue(curNode, startNode)+startNode.G;
                    if (newg < curNode.G)
                    {
                        curNode.G = newg;
                        curNode.Parent = startNode;
                    }
                    //否则,不做操作
                }
            }

            //4.若当前节点为目标节点则执行操作6
            if (startNode != endNode)
            {
                //没有可走点却没找到终点,寻路失败
                if (OpenList.Count == 0)
                {
                    return new List<Node>();
                }

                Node nextNode = null;
                //6.重复以上步骤
                foreach (Node curNode in OpenList)
                {
                    if (nextNode == null)
                    {
                        nextNode = curNode;
                    }
                    else if (nextNode.F >= curNode.F)
                    {
                        nextNode = curNode;
                    }
                }
                return FindWayByAStart(nextNode, endNode);
            }
            else
            {
                //7.通过当前节点的父节点一层层往上遍历,得到目标路径节点的倒序排列.
                List<Node> way = new List<Node>();
                List<Node> backWay = new List<Node>();
                Node curNode = startNode;
                while (true)
                {
                    backWay.Add(curNode);

                    if (curNode.Parent == null)
                    {
                        backWay.Remove(curNode);
                        backWay.Remove(startNode);
                        break;
                    }
                    else
                    {
                        curNode = curNode.Parent;
                    }
                }

                Node[] nodes = backWay.ToArray();

                for (int i = nodes.Length - 1; i >= 0; i--)
                {
                    way.Add(nodes[i]);
                }
                return way;
            }
   
        }

        internal class Node
        {
            public int F {
                get { return G + H; }
            }

            public int G;
            public int H;

            public Node Parent;
        }

        int GetGValue(Node a, Node b)
        {
            //TODO
            return 0;
        }

        int GetHValue(Node a, Node b)
        {
            //TODO
            return 0;
        }
    }
}