A*算法实现9宫格拼图游戏最优解

目标：用A*算法解决拼图的最优路径解

 

A*算法介绍

        ​A* （A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是许多其他问题的常用启发式算法。

       在计算机科学中，A*算法作为Dijkstra算法的扩展，因其高效性而被广泛应用于寻路及图的遍历，如星际争霸等游戏中就大量使用。在理解算法前，我们需要知道几个概念：

• 搜索区域（The Search Area）：图中的搜索区域被划分为了简单的二维数组，数组每个元素对应一个小方格，当然我们也可以将区域等分成是五角星，矩形等，通常将一个单位的中心点称之为搜索区域节点（Node）。　　
• 开放列表(Open List)：我们将路径规划过程中待检测的节点存放于Open List中，而已检测过的格子则存放于Close List中。
• 父节点（parent）：在路径规划中用于回溯的节点，开发时可考虑为双向链表结构中的父结点指针。
• 路径排序（Path Sorting）：具体往哪个节点移动由以下公式确定：F(n) = G + H 。G代表的是从初始位置A沿着已生成的路径到指定待检测格子的移动开销。H指定待测格子到目标节点B的估计移动开销。
• 启发函数（Heuristics Function）：H为启发函数，也被认为是一种试探，由于在找到唯一路径前，我们不确定在前面会出现什么障碍物，因此用了一种计算H的算法，具体根据实际场景决定。在我们简化的模型中，H采用的是传统的曼哈顿距离（Manhattan Distance），也就是横纵向走的距离之和。

A*算法的步骤　　

如下图所示，绿色方块为机器人起始位置A，红色方块为目标位置B，蓝色为障碍物。

        我们把要搜寻的区域划分成了正方形的格子。这是寻路的第一步，简化搜索区域。这个特殊的方法把我们的搜索区域简化为了 2 维数组。数组的每一项代表一个格子，它的状态就是可走 (walkalbe)或不可走 (unwalkable) 。现用A*算法寻找出一条自A到B的最短路径，每个方格的边长为10，即垂直水平方向移动开销为10。因此沿对角移动开销约等于14。具体步骤如下：

　　从起点 A 开始，把它加入到一个由方格组成的open list(开放列表) 中，这个open list像是一个购物清单。Open list里的格子是可能会是沿途经过的，也有可能不经过。因此可以将其看成一个待检查的列表。查看与A相邻的8个方格 ，把其中可走的 (walkable) 或可到达的(reachable) 方格加入到open list中。并把起点 A 设置为这些方格的父节点 (parent node) 。然后把 A 从open list中移除，加入到close list(封闭列表) 中，close list中的每个方格都是不需要再关注的。

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

        下一步，我们需要从open list中选一个与起点A相邻的方格。但是到底选择哪个方格好呢？选F值最小的那个。我们看看下图中的一些方格。在标有字母的方格中G = 10 。这是因为水平方向从起点到那里只有一个方格的距离。与起点直接相邻的上方，下方，左方的方格的 G 值都是 10 ，对角线的方格 G 值都是14 。H值通过估算起点到终点 ( 红色方格 ) 的 Manhattan 距离得到，仅作横向和纵向移动，并且忽略沿途的障碍。使用这种方式，起点右边的方格到终点有3 个方格的距离，因此 H = 30 。这个方格上方的方格到终点有 4 个方格的距离 ( 注意只计算横向和纵向距离 ) ，因此 H = 40 。

        比较open list中节点的F值后，发现起点A右侧节点的F=40，值最小。选作当前处理节点，并将这个点从Open List删除，移到Close List中。

        对这个节点周围的8个格子进行判断，若是不可通过（比如墙，水，或是其他非法地形）或已经在Close List中，则忽略。否则执行以下步骤：

• 若当前处理节点的相邻格子已经在Open List中，则检查这条路径是否更优，即计算经由当前处理节点到达那个方格是否具有更小的 G值。如果没有，不做任何操作。相反，如果G值更小，则把那个方格的父节点设为当前处理节点 ( 我们选中的方格 ) ，然后重新计算那个方格的 F 值和 G 值。
• 若当前处理节点的相邻格子不在Open List中，那么把它加入，并将它的父节点设置为该节点。

　　按照上述规则我们继续搜索，选择起点右边的方格作为当前处理节点。它的外框用蓝线打亮，被放入了close list 中。然后我们检查与它相邻的方格。它右侧的3个方格是墙壁，我们忽略。它左边的方格是起点，在 close list 中，我们也忽略。其他4个相邻的方格均在 open list 中，我们需要检查经由当前节点到达那里的路径是否更好。我们看看上面的方格，它现在的G值为14 ，如果经由当前方格到达那里， G值将会为20( 其中10为从起点到达当前方格的G值，此外还要加上从当前方格纵向移动到上面方格的G值10) ，因此这不是最优的路径。看图就会明白直接从起点沿对角线移动到那个方格比先横向移动再纵向移动要好。

　　当把4个已经在 open list 中的相邻方格都检查后，没有发现经由当前节点的更好路径，因此不做任何改变。接下来要选择下一个待处理的节点。因此再次遍历open list ，现在open list中只有 7 个方格了，我们需要选择F值最小的那个。这次有两个方格的F值都是54，选哪个呢？没什么关系。从速度上考虑，选择最后加入 open list 的方格更快。因此选择起点右下方的方格，如下图所示。

 

　　接下来把起点右下角F值为54的方格作为当前处理节点，检查其相邻的方格。我们发现它右边是墙（墙下面的一格也忽略掉，假定墙角不能直接穿越)，忽略之。这样还剩下 5 个相邻的方格。当前方格下面的 2 个方格还没有加入 open list ，所以把它们加入，同时把当前方格设为他们的父亲。在剩下的 3 个方格中，有 2 个已经在 close list 中 ( 一个是起点，一个是当前方格上面的方格，外框被加亮的 ) ，我们忽略它们。最后一个方格，也就是当前方格左边的方格，检查经由当前方格到达那里是否具有更小的 G 值。没有，因此我们准备从 open list 中选择下一个待处理的方格。

　　不断重复这个过程，直到把终点也加入到了 open list 中，此时如下图所示。注意在起点下方 2 格处的方格的父亲已经与前面不同了。之前它的G值是28并且指向它右上方的方格。现在它的 G 值为 20 ，并且指向它正上方的方格。这是由于在寻路过程中的某处使用新路径时G值更小，因此父节点被重新设置，G和F值被重新计算。

 

       那么我们怎样得到实际路径呢？很简单，如下图所示，从终点开始，沿着箭头向父节点移动，直至回到起点，这就是你的路径。

A*算法总结：

　　1. 把起点加入 open list 。

　　2. 重复如下过程：

　　　　a. 遍历open list ，查找F值最小的节点，把它作为当前要处理的节点，然后移到close list中

　　　　b. 对当前方格的 8 个相邻方格一一进行检查，如果它是不可抵达的或者它在close list中，忽略它。否则，做如下操作：

　　　　□  如果它不在open list中，把它加入open list，并且把当前方格设置为它的父亲

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

　　　　c. 遇到下面情况停止搜索：

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

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

　　3. 从终点开始，每个方格沿着父节点移动直至起点，形成路径。

 

如何来解决拼图问题

       普通的A*算法介绍和实现过程都是解决单体单目标的路由问题，好像和拼图没有什么关系。拼图需要解决的是多个图片碎片任务多个目标的问题。路径也看似动态网格，不太容易联想到A*算法。那我们仔细思考一下，我们是否可以按照A*算法的主体思想，去计算移动的最小代价呢？其实可以的，我们把每个碎片在没有其他碎片障碍的情况下移动到它自己的目标位置所需要的步数算出来，然后求和不就是最小代价吗？

       套用上面总结的步骤。F值就是每个碎片归位的最小步数。相邻的方格，其实就是下一步能移动的碎片的方法。以下是关键步骤的代码。

       需要完整源码或者体验程序的可以请关注并私聊我哦。

        class Steps
        {
            public List CurArry;
            public int Distance;
            public int StepCount;
            public Steps prevStep;
        }

        List intArry = new List() { 0, 1, 2, 3, 4, 5, 6, 7, -1 };

        List listWhiteSteps = new List();
        Dictionary AllSteps = new Dictionary();
        List listCurretSteps = new List();

        private void Compute()
        {
            listWhiteSteps.Clear();
            AllSteps.Clear();
            Steps topStep = new Steps();
            topStep.CurArry = intArry;
            topStep.Distance = MathDistance(topStep.CurArry);
            topStep.StepCount = 0;
            topStep.prevStep = null;
            listWhiteSteps.Add(topStep);
            bool finish = false;
            allMinStep = topStep;
            while (!finish)
            {
                finish = ComputeSteps(allMinStep);
            }
        }
        Steps allMinStep = null;
        private bool ComputeSteps(Steps step)
        {
            if (step.Distance == 0)
            {
                //已经找到最终结果。
                listCurretSteps.Add(step);
                Steps prevStep = step.prevStep;
                while (prevStep != null)
                {
                    listCurretSteps.Insert(0, prevStep);
                    prevStep = prevStep.prevStep;
                }
                listCurretSteps.RemoveAt(0);
                return true;
            }
            //计算所有可能的下一步
            List nextSteps = MathNextSteps(step);
            allMinStep = FindMinStep(nextSteps);
            if (allMinStep == null)
            {
                tbAlert.Text = "未找到合适的路径！";
                return true;
            }
            return false;
        }

        private Steps FindMinStep(List nextSteps)
        {
            int mindis = -1;
            Steps minStep = null;
            if (nextSteps.Count > 0)
            {
                foreach (Steps step in nextSteps)
                {
                    if (mindis == -1)
                    {
                        mindis = step.Distance + step.StepCount;
                        minStep = step;
                    }
                    if (mindis > step.Distance + step.StepCount)
                    {
                        mindis = step.Distance + step.StepCount;
                        minStep = step;
                    }
                }
            }
            else
            {
                foreach (Steps step in listWhiteSteps)
                {
                    if (mindis == -1)
                    {
                        mindis = step.Distance + step.StepCount;
                        minStep = step;
                    }
                    if (mindis > step.Distance + step.StepCount)
                    {
                        mindis = step.Distance + step.StepCount;
                        minStep = step;
                    }
                }
            }
            return minStep;
        }

        private List MathNextSteps(Steps prevStep)
        {
            List list = prevStep.CurArry;
            List nextSteps = new List();
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i] == -1)
                {
                    List changeIndex = new List();
                    //上
                    if (i > 2)
                    {
                        changeIndex.Add(i - 3);
                    }
                    //左
                    if (i % 3 != 0)
                    {
                        changeIndex.Add(i - 1);
                    }
                    //右
                    if ((i + 1) % 3 != 0)
                    {
                        changeIndex.Add(i + 1);
                    }
                    //下
                    if (i < 6)
                    {
                        changeIndex.Add(i + 3);
                    }
                    for (int j = 0; j < changeIndex.Count; j++)
                    {
                        List childList = new List(list);
                        int number = childList[changeIndex[j]];
                        childList[changeIndex[j]] = -1;
                        childList[i] = number;
                        Steps step = new Steps();
                        step.CurArry = childList;
                        step.prevStep = prevStep;
                        step.StepCount = prevStep.StepCount + 1;
                        step.Distance = MathDistance(childList);
                        string checkStr = StepToString(step);
                        if (!AllSteps.ContainsKey(checkStr))
                        {
                            AllSteps.Add(checkStr, step);
                            listWhiteSteps.Add(step);
                            if (step.Distance < prevStep.Distance)
                            {
                                nextSteps.Add(step);
                            }
                        }
                        else
                        {
                            if (step.StepCount < AllSteps[checkStr].StepCount)
                            {
                                Steps changeStep = AllSteps[checkStr];
                                changeStep.StepCount = step.StepCount;
                                changeStep.prevStep = prevStep;
                                if (!listWhiteSteps.Contains(changeStep))
                                {
                                    listWhiteSteps.Add(changeStep);
                                }
                                if (step.Distance < prevStep.Distance)
                                {
                                    nextSteps.Add(step);
                                }
                            }
                        }
                    }
                    break;
                }
            }
            listWhiteSteps.Remove(prevStep);
            return nextSteps;
        }

        private string StepToString(Steps step)
        {
            string str = "";
            for (int i = 0; i < step.CurArry.Count; i++)
            {
                str += step.CurArry[i].ToString();
            }
            return str;
        }


        private int MathDistance(List list)
        {
            int distance = 0;
            for (int i = 0; i < list.Count; i++)
            {
                int curPos = i;
                int tarPos = list[i];
                if (tarPos == -1)
                {
                    tarPos = 8;
                }
                int steps = tarPos - curPos;
                if (steps < 0)
                {
                    steps = -steps;
                }
                steps = steps / 3 + steps % 3;
                distance += steps;
            }
            return distance;
        }