15-Puzzle Game

N-Puzzle Game

N-Puzzle 是一种滑块类推盘游戏，常见的有15-puzzle和8-puzzle。

如下图所示，由15个方块和一个空位组成，规则很简单，移动方块，让所有的方块按照数字的顺序排列。

 使用Silverlight实现如下：

 那么如何使用算法来解决15-puzzle，已得到一个在任意状态下到达最终按顺序排列的一个路径呢？
IDA*(Iterative Deepening A*) 算法

IDA*是迭代加深的A*算法，深度优先，一次只记录一条路径，减少空间需求。

简单来说，给定一个限定值limit，开始深度优先搜索，当前节点的F()（估值函数）值超过limit时结束，然后每次增加limit，循环迭代搜索直到找到最终路径。

1. GoalState : 最终按数字顺序排列的状态

2. StartState ： 任意打乱顺序的开始状态

3. IsResolved : 判断当前状态是否已达到GoalState

4. Manhattan Distance ： 对于当前状态的任一点 P1（X1，Y1），到其值在目标状态的位置 P2（X2，Y2）的距离， D= Abs(X1-X2) + Abs(Y1-Y2)

算法如下：

    public class PuzzleNode 
    {
        public PuzzleNode(int[] state, int blank, PuzzleNode node)
        {
            this.state = state;
            this.BlankPosition = blank;
            this.parent = node;
            if (parent != null)
                cost = parent.Cost + 1;
        }

        /// <summary>
        /// The current state
        /// </summary>
        /// <returns></returns>
        public int[] CurrentState()
        {
            return state;
        }

        /// <summary>
        /// Total cost
        /// </summary>
        public int Cost { get { return cost; } }

        /// <summary>
        /// The position of blank 
        /// </summary>
        public int BlankPosition { get; set; }

        /// <summary>
        /// The move from parent to the current node
        /// </summary>
        public Direction Direction { get; set; }

        private int[] state;
        private int cost;
        private PuzzleNode parent;
    }

public List<PuzzleNode> IDAStar(int[] startboard)
{
    int limit = SearchHelper.Heuristic(root);

    List<PuzzleNode> solution = null;
    List<PuzzleNode> path = new List<PuzzleNode>();
    path.Add(root);
    while (solution == null)
    {
        solution = DepthLimitSearch(limit, path);
        limit += 1;
    }

    return solution;
}

private List<PuzzleNode> DepthLimitSearch(int cost, List<PuzzleNode> path)
{
    if (cost >= Int32.MaxValue)
        throw new ArgumentException("cost over flow");

    var node = path.Last();
    if (IsSolved(node))
    {
        return path;
    }

    foreach (var child in GetSuccessors(node))
    {
        if (((int)child.Direction + (int)node.Direction != 0) && (SearchHelper.Heuristic(child) + child.Cost) <= cost)
        {
            var nextpath = new List<PuzzleNode>(path);
            nextpath.Add(child);
            var solution = DepthLimitSearch(cost, nextpath);
            if (solution != null)
            {
                return solution;
            }
        }
    }
    return null;

我们将数字换成图片，变成一个拼图游戏。大家来试一下吧。