启发式搜索 - 有趣而神奇的 A* 算法

前言

在课堂上听老师讲了一个人工智能的基础小算法，感觉神奇而有趣，便自行研究一下。研究了几个小时，总算实现了。想写一篇博文来记录一下今天的学习经历，那么，就请有兴趣的各位跟我一起从零实现一个简单的A星寻路算法啦。

概述

• 首先，需要有个基本概念：A*搜寻算法俗称“A星算法”。这是一种在图形平面上，有多个节点的路径，求出最低通过成本的算法。（启发式搜索）

几个要素

• 是否相通的标记（标记有许多种方式，例如：0为通畅、1为障碍；或者把两两结点的线路保存下来，再去查该线路是否存在）
• 一个父亲结点指针（处理结点时候，需要知道该结点的父节点）
• OPEN 表（待检查的点，认为当前点为父亲结点，父亲结点也要保存，）
• CLOSE 表（不再检查的点）
• 一条公式：F = H + G
  F 为到终点的总耗费
  H 为网格上当前方格移动到终点的预估耗费（预估算法有很多种，例如：“曼哈顿法”：H = |行数| + |列数|、另外也可利用直线距离…）；
  G 为父亲结点移动到当前结点的预估移动耗费；

• 现在，再来举个栗子，下面的步骤解析也会与之相结合：

  简单解释：

  • 图中有 A、B、C、D、E、F、G、H 8个结点（ A 为起点、E 为终点）
  • 括号为当前结点到终点的预估值（由于预估算法的选择有许多，使用时需要根据实际情况选择，而我们现在优先学习A星算法的思路，因此这里直接给出预估值 - 即 H 值）
  • 结点间的连线为相同直线，上面的数字代表线路的移动耗费值（即 G 值）
  • 任务：利用A星算法计算出路线

算法步骤

1. 设起点 A ，将 A 加入 OPEN 表
2. 寻找相邻可达点，计算出其 F 值，并加入 OPEN 表；若相邻点已经在 Open 表中，则判断其是否需要更新 F 值；若相邻点已经在 Close 表中，则跳过该点
3. 将原父亲结点（A 结点）从 OPEN 表中删除，把它加入到 CLOSE 表中
4. 从 OPEN 表中选择一个 F值最小的，然后将它作为父亲结点，继续处理其相邻结点
5. 只要 Open 表不为空，则循环执行上述2、3、4步骤，发现相邻点是终点，则跳出循环。
6. 当 Open 表为空，还没有找到终点，则说明起点不可达到终点

Just show me the code ！

讲了那么多，理论知识总该要实践才行，建议大家先参考伪代码，理解好算法思路，自行尝试实现一番，再去看我那些半桶水的实现代码，一定会有更多收获的。

一段核心思路伪代码：

while(OPEN!=NULL)
{
    从OPEN表中取f(n)最小的节点n;
    if(n节点==目标节点)
        break;
    for(当前节点n的每个子节点X)
    {
        计算f(X);
        if(XinOPEN)
            if(新的f(X)if(XinCLOSE)
            continue;
        if(Xnotinboth)
        {
            把n设置为X的父亲;
            求f(X);
            并将X插入OPEN表中;//还没有排序
        }
    }//endfor
    将n节点插入CLOSE表中;
    按照f(n)将OPEN表中的节点排序;//实际上是比较OPEN表内节点f的大小，从最小路径的节点向下进行。
}//endwhile(OPEN!=NULL)

我的 Java 实现代码：

package com.goo.astart;
/**
 *路径实体类
 * 
 * @author Goo
 * 
 */
public class Road {
    public String name;
    public int length;
    public Road(String name, int length) {
        this.name = name;
        this.length = length;
    }
}

package com.goo.astart;
/**
 * 结点实体类
 * 
 * @author Goo
 * 
 */
public class NodeStruct {
    public NodeStruct(String nodeName, int estimate) {
        this.nodeName = nodeName;
        this.estimate = estimate;
    }
    /**
     * 结点名称
     */
    public String nodeName;
    /**
     * 父亲结点
     */
    public NodeStruct fatherNode = null;
    /**
     * 总耗费
     */
    public int weight = 0;
    /**
     * 当前结点到终点的预估耗费
     */
    public int estimate = 0;
    /**
     * 父亲结点到当前结点的实际耗费
     */
    public int practical = 0;
}

//Main.java
package com.goo.astart;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import javax.management.openmbean.OpenDataException;
import javax.xml.soap.Node;
/**
 * 含有主方法的主逻辑类
 * 
 * @author Goo
 * 
 */
public class Main {
    private static ArrayList dataList = new ArrayList();
    private static ArrayList roadList = new ArrayList();
    private static ArrayList openList = new ArrayList();
    private static ArrayList closeList = new ArrayList();
    private static NodeStruct startNode;
    private static NodeStruct endNode;
    private static final int HASFOUND = 10000;
    private static final int NOTFOUND = 20000;
    private static int stepCount = 0;
    public static void main(String[] args) {
        loadData();
        // 1、将起点加入Open表
        addToOpenList(startNode);
        // 2、搜索相邻路径？
        if (search() == HASFOUND) {
            System.out.println("路径搜索完成，成功找到最短路径");
        } else {
            System.out.println("路径搜索完成，没有可达路径");
        }
    }
    /**
     * A星核心算法
     * 
     * @return
     */
    private static int search() {
        // Open表不为空
        while (openList.size() != 0) {
            // 按照总耗费从小到大排序
            Collections.sort(openList, new Comparator() {
                public int compare(NodeStruct node1, NodeStruct node2) {
                    return node1.weight - node2.weight;
                };
            });
            // 取最小结点作为父亲结点
            NodeStruct fatherNode = openList.get(0);
            stepCount++;
            System.out.println("步骤" + stepCount + ":" + fatherNode.nodeName
                    + " - 结点F值：" + fatherNode.weight);
            // 结点已找到
            if (fatherNode.equals(endNode)) {
                return HASFOUND;
            }
            // 寻找相邻路径
            for (int i = 0; i < dataList.size(); i++) {
                NodeStruct neighNode = dataList.get(i);
                String roadName = neighNode.nodeName + fatherNode.nodeName;
                String roadNameRev = fatherNode.nodeName + neighNode.nodeName;
                for (int j = 0; j < roadList.size(); j++) {
                    Road tempRoad = roadList.get(j);
                    // 找到相邻点
                    if (roadName.equals(tempRoad.name)
                            || roadNameRev.equals(tempRoad.name)) {
                        // 如果在Close表中，忽略
                        if (closeList.contains(neighNode)) {
                            continue;
                        }
                        else if (openList.contains(neighNode)) {
                            // 如果在Open表中
                            // 如果父亲结点到该结点耗费值更小，则更新耗费值
                            if (tempRoad.length + neighNode.estimate < neighNode.weight) {
                                neighNode.weight = tempRoad.length
                                        + neighNode.estimate;
                            }
                        } else {
                            // 两个表都没有（空白点）
                            // 计算该点总耗费
                            neighNode.weight = neighNode.estimate
                                    + tempRoad.length;
                            // 成功搜索路径，认为是相邻点，加入到Open表
                            addToOpenList(neighNode);
                        }
                    }
                }
            }
            // 最后将父结点移除Open表，放入Close表
            removeFromOpen(fatherNode);
            addToCloseList(fatherNode);
        }
        return NOTFOUND;
    }
    /**
     * 加载数据
     */
    private static void loadData() {
        startNode = new NodeStruct("A", 15);
        startNode.weight = 15;
        endNode = new NodeStruct("E", 0);
        dataList.add(startNode);
        dataList.add(endNode);
        dataList.add(new NodeStruct("B", 14));
        dataList.add(new NodeStruct("C", 10));
        dataList.add(new NodeStruct("D", 2));
        dataList.add(new NodeStruct("F", 5));
        dataList.add(new NodeStruct("G", 9));
        dataList.add(new NodeStruct("H", 11));
        roadList.add(new Road("AB", 3));
        roadList.add(new Road("AH", 4));
        roadList.add(new Road("BH", 5));
        roadList.add(new Road("CG", 3));
        roadList.add(new Road("CD", 8));
        roadList.add(new Road("CB", 4));
        roadList.add(new Road("DG", 8));
        roadList.add(new Road("DF", 3));
        roadList.add(new Road("DE", 2));
        roadList.add(new Road("FG", 4));
        roadList.add(new Road("GH", 2));
    }
    /**
     * 添加到 Open 表
     * 
     * @param node
     */
    private static void addToOpenList(NodeStruct node) {
        openList.add(node);
    }
    /**
     * 添加到 Close 表
     * 
     * @param node
     */
    private static void addToCloseList(NodeStruct node) {
        closeList.add(node);
    }
    /**
     * 从 Open 表移除
     * 
     * @param node
     */
    private static void removeFromOpen(NodeStruct node) {
        openList.remove(node);
    }
    /**
     * 从 Close 表移除
     * 
     * @param node
     */
    private static void removeFromClose(NodeStruct node) {
        closeList.remove(node);
    }
}

总结

相信大家动手实现后，就会对A*算法有个基本的认识啦，以上代码通过了几个简单的样例，但不排除会隐藏着奇怪的 Bug 噢，或者是一段有待改进的代码，欢迎大家指点指点。