算法之A星算法（寻路）

1.启发式搜索：启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无谓的搜索路径，提高了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。

　　启发算法有： 蚁群算法，遗传算法、模拟退火算法等。

2.估价算法：从当前节点移动到目标节点的预估损耗。

　　预估算法有：曼哈顿（manhattan）等。

3.算法特点：理论上时间是最优的，但空间增长是指数型的。

4.java实现：上下左右移动

package cn.liushaofeng.algorithm;

import java.util.ArrayList;
import java.util.List;

/**
 * A Star Algorithm
 * @author liushaofeng
 * @date 2015-8-24 下午11:05:48
 * @version 1.0.0
 */
public class AstarAlgorithm
{
    private List<Node> openList = null;
    private List<Node> closeList = null;
    private int[][] map;

    /**
     * default constructor
     * @param map data map
     */
    public AstarAlgorithm(int[][] map)
    {
        this.map = map;
        this.openList = new ArrayList<Node>();
        this.closeList = new ArrayList<Node>();
    }

    /**
     * find path
     * @param srcNode source node
     * @param desNode destination node
     * @return node path
     */
    public Node findPath(Node srcNode, Node desNode)
    {
        init(srcNode);
        do
        {
            if (openList.isEmpty())
            {
                break;
            }

            Node node = openList.get(0);
            List<Node> aroundPoint = getAroundPoint(srcNode, node, desNode);
            openList.addAll(aroundPoint);
            closeList.add(node);
            openList.remove(node);

        } while (!findDes(desNode));

        return findNodePath(desNode);
    }

    private Node findNodePath(Node desNode)
    {
        for (Node node : openList)
        {
            if (node.getX() == desNode.getX() && node.getY() == desNode.getY())
            {
                return node;
            }
        }
        return null;
    }

    private boolean findDes(Node desNode)
    {
        for (Node node : openList)
        {
            if (node.getX() == desNode.getX() && node.getY() == desNode.getY())
            {
                return true;
            }
        }
        return false;
    }

    private void init(Node srcNode)
    {
        openList.add(srcNode);
    }

    // top bottom left and right, four points
    private List<Node> getAroundPoint(Node srcNode, Node nextNode, Node desNode)
    {
        int x = srcNode.getX();
        int y = srcNode.getY();

        int[] xData = new int[2];
        int[] yData = new int[2];
        if (x - 1 >= 0)
        {
            xData[0] = x - 1;
        }
        if (x + 1 < map.length)
        {
            xData[1] = x + 1;
        }

        if (y - 1 >= 0)
        {
            yData[0] = y - 1;
        }
        if (y + 1 < map[0].length)
        {
            yData[1] = y + 1;
        }

        List<Node> tmpList = new ArrayList<Node>();

        for (int i : xData)
        {
            Node node = new Node(i, y, srcNode);
            if (!isObstacle(node) && !inClosetList(node))
            {
                calcWeight(srcNode, node, desNode);
                tmpList.add(node);
            }
        }

        for (int i : yData)
        {
            Node node = new Node(x, i, srcNode);
            if (!isObstacle(node) && !inClosetList(node))
            {
                calcWeight(srcNode, node, desNode);
                tmpList.add(node);
            }
        }

        return tmpList;
    }

    private void calcWeight(Node parentNode, Node node, Node desNode)
    {
        node.setG(parentNode.getG() + 10);
        int h = Math.abs(node.getX() - desNode.getX()) + Math.abs(node.getY() - desNode.getY());
        node.setWeight(node.getG() + h * 10);
    }

    private boolean inClosetList(Node nextNode)
    {
        for (Node node : closeList)
        {
            if (node.getX() == nextNode.getX() && node.getY() == nextNode.getY())
            {
                return true;
            }
        }
        return false;
    }

    private boolean isObstacle(Node nextNode)
    {
        return map[nextNode.getX()][nextNode.getY()] == 1;
    }

    public static void main(String[] args)
    {
        int[][] map =
        {
        { 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 1, 0, 0, 0 },
        { 0, 0, 0, 1, 0, 0, 0 },
        { 0, 0, 0, 1, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 0, 0 } };

        AstarAlgorithm astar = new AstarAlgorithm(map);
        Node pathNode = astar.findPath(new Node(3, 1, null), new Node(3, 5, null));
        System.out.println(pathNode == null ? "Can not find path!" : pathNode.toString());
    }
}

数据模型

package cn.liushaofeng.algorithm;

import java.util.ArrayList;
import java.util.List;

/**
 * Node
 * @author liushaofeng
 * @date 2015-8-24 下午09:48:53
 * @version 1.0.0
 */
public class Node
{
    private Node parentNode;
    private int x;
    private int y;

    private int weight;
    private int g;

    /**
     * default constructor
     * @param x x point
     * @param y y point
     * @param parentNode parent node
     */
    public Node(int x, int y, Node parentNode)
    {
        this.x = x;
        this.y = y;
        this.parentNode = parentNode;
    }

    public int getG()
    {
        return g;
    }

    public void setG(int g)
    {
        this.g = g;
    }

    public Node getParentNode()
    {
        return parentNode;
    }

    public void setParentNode(Node parentNode)
    {
        this.parentNode = parentNode;
    }

    public int getX()
    {
        return x;
    }

    public void setX(int x)
    {
        this.x = x;
    }

    public int getY()
    {
        return y;
    }

    public void setY(int y)
    {
        this.y = y;
    }

    public int getWeight()
    {
        return weight;
    }

    public void setWeight(int weight)
    {
        this.weight = weight;
    }

    @Override
    public String toString()
    {
        return getPath();
    }

    private String getPath()
    {
        List<Node> dataList = new ArrayList<Node>();
        Node node = this;
        while (node != null)
        {
            dataList.add(node);
            node = node.getParentNode();
        }

        StringBuffer sb = new StringBuffer();
        for (int i = dataList.size() - 1; i >= 0; i--)
        {
            if (i == 0)
            {
                sb.append("(" + dataList.get(i).getX() + "," + dataList.get(i).getY() + ")");
            } else
            {
                sb.append("(" + dataList.get(i).getX() + "," + dataList.get(i).getY() + ")->");
            }
        }
        return sb.toString();
    }
}

 代码待调试。