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;

我們將數字換成圖片，變成一個拼圖游戲。大家來試一下吧。