Coursera Algorithms Programming Assignment 4: 8 Puzzle （100分）

題目原文：http://coursera.cs.princeton.edu/algs4/assignments/8puzzle.html

題目要求：設計一個程序解決8 puzzle問題以及該問題的推廣，例如8-puzzle是3*3，程序要能解決n*n的同類問題（2 ≤ n < 128） 

典型的8 puzzle如下：

算法設計參照A*搜索算法，即使不了解A*搜索算法，題目也已經將解法解釋的很具體了。

Best-first search：設計參照A* 搜索算法。定義一個 search node類，包含board，從初始狀態到達當前board狀態的移動權重moves，和previous search node。

1. 插入初始的search node，其board設為初始board，moves設為0，previous search node設置為0
2. 將初始化的search node置於MinPQ類型的優先級隊列中
3. 刪除優先級隊列中的min節點，再將該節點的鄰居節點放入優先級隊列中。
4. 重復2和3操作直至從優先級隊列中刪除的min節點是目標board

 

A* 搜索算法的優先級判定依據是f(n) = g(n) + h(n)，g(n)是從初始節點到達當前節點的代價，h(n)是當前節點到目標節點的預估代價。

在本題中search node中的moves就是g(n)，而關於h(n)題目給出了兩種候選：

Hamming priority function:  處於錯誤位置的block的個數（空白處不算block）

Manhatten priority function: 處於錯誤位置的block距離其各自目標位置的橫向和縱向距離之和

h(n)采用這兩者均可，根據題目中的圖示，顯然發現題目推薦采用manhatten方法。

至此優先級隊列中的優先級判斷依據就是當前search node的moves+manhatten value

 

A critical optimization: 上述Best-first search中可能會存在剛出隊列的節點又被當成其鄰居節點的鄰居而被放回優先級隊列的情況，這種情況會造成很大的性能損失。為了阻止這種情況的發生，可以在Best-first search的第3步“將該節點的鄰居節點放入優先級隊列”時比較下這個鄰居節點的board是否與本節點的board相同。

例如此時{{8，1，3}，{4，0，2}，{7，6，5}}就不應該放入優先級隊列中。

A second optimization: 建議在search node的構造函數中計算其manhattan值，也就是在search node的構造函數中確定其優先級。

Detecting unsolvable puzzles：如果一個board是不可解的，那么隨便在該board中選擇一對block互換位置，就能將其變為可解的。為此采用同時對board和其互換了一對block的twindboard進行求解，如果board先實現目標解，那么其就是可解的，相反，如果twinboard先實現目標節，那么該board就不可解。

import java.util.ArrayList;
/**
 * @author evasean www.cnblogs.com/evasean/
 */
public class Board {
    private static final int BLANK = 0;
    private final int n;
    private int[][] blocks;

    public Board(int[][] inBlocks) {
        // construct a board from an n-by-n array of blocks
        // (where blocks[i][j] = block in row i, column j)
        n = inBlocks.length;
        blocks = new int[n][n];
        copy(blocks, inBlocks);
    }

    private void copy(int[][] toBlocks, int[][] fromBlocks) {
        for (int row = 0; row < n; row++)
            for (int col = 0; col < n; col++)
                toBlocks[row][col] = fromBlocks[row][col];
    }

    public int dimension() {
        // board dimension n
        return n;
    }

    private int getRow(int value) {
        return (value - 1) / n;
    }

    private int getCol(int value) {
        return (value - 1) % n;
    }

    private int getValue(int row, int col) {
        return row * n + col + 1;
    }

    public int hamming() {
        // number of blocks out of place
        int hamming = 0;
        for (int row = 0; row < n; row++)
            for (int col = 0; col < n; col++)
                if (blocks[row][col] != BLANK && blocks[row][col] != getValue(row, col))
                    hamming++;
        return hamming;
    }

    public int manhattan() {
        // sum of Manhattan distances between blocks and goal
        int manhattan = 0;
        for (int row = 0; row < n; row++)
            for (int col = 0; col < n; col++)
                if (blocks[row][col] != BLANK && blocks[row][col] != getValue(row, col))
                    manhattan += Math.abs(getRow(blocks[row][col]) - row) + Math.abs(getCol(blocks[row][col]) - col);
        return manhattan;
    }

    public boolean isGoal() {
        // is this board the goal board?
        for (int row = 0; row < n; row++)
            for (int col = 0; col < n; col++)
                if (blocks[row][col] != BLANK && blocks[row][col] != getValue(row, col))
                    return false;
        return true;
    }

    public Board twin() {
        // a board that is obtained by exchanging any pair of blocks
        Board twinBoard = new Board(blocks);
        int firRow = 0;
        int firCol = 0;
        if (blocks[firRow][firCol] == BLANK)
            firCol++;
        for (int row = 0; row < n; row++) {
            for (int col = 0; col < n; col++) {
                if (blocks[row][col] != blocks[firRow][firCol] && blocks[row][col] != BLANK) {
                    twinBoard.swap(firRow, firCol, row, col);
                    return twinBoard;
                }
            }
        }
        return twinBoard;
    }

    private void swap(int vRow, int vCol, int wRow, int wCol) {
        int t = blocks[vRow][vCol];
        blocks[vRow][vCol] = blocks[wRow][wCol];
        blocks[wRow][wCol] = t;
    }

    public boolean equals(Object y) {
        // does this board equal y?
        if (y == null)
            return false;
        if (y == this)
            return true;
        if (y.getClass().isInstance(this)) {
            Board yb = (Board) y;
            if (yb.n != this.n)
                return false;
            else {
                for (int row = 0; row < n; row++)
                    for (int col = 0; col < n; col++)
                        if (yb.blocks[row][col] != blocks[row][col])
                            return false;
                return true;
            }
        } else
            return false;
    }

    public Iterable<Board> neighbors() {
        // all neighboring boards
        ArrayList<Board> neighbors = new ArrayList<Board>();
        for (int row = 0; row < n; row++) {
            for (int col = 0; col < n; col++) {
                if (blocks[row][col] == BLANK) {
                    // 空白的位置分別與上下左右的元素交換一次位置就得到一個鄰居board
                    // 與上方元素互換
                    if (row > 0) {
                        Board neighborT = new Board(blocks);
                        neighborT.swap(row, col, row - 1, col);
                        neighbors.add(neighborT);
                    }
                    // 與下方元素互換
                    if (row < n - 1) {
                        Board neighborB = new Board(blocks);
                        neighborB.swap(row, col, row + 1, col);
                        neighbors.add(neighborB);
                    }
                    // 與左邊元素互換
                    if (col > 0) {
                        Board neighborL = new Board(blocks);
                        neighborL.swap(row, col, row, col - 1);
                        neighbors.add(neighborL);
                    }
                    // 與右邊元素互換
                    if (col < n - 1) {
                        Board neighborR = new Board(blocks);
                        neighborR.swap(row, col, row, col + 1);
                        neighbors.add(neighborR);
                    }
                }
            }
        }
        return neighbors;
    }

    public String toString() {
        // string representation of this board (in the output format specified
        // below)
        StringBuilder sb = new StringBuilder();
        sb.append(n + "\n");
        for (int row = 0; row < n; row++) {
            for (int col = 0; col < n; col++) {
                //本來考慮到n<128時元素可能會很大，設置的是%6d，但是提交時不滿足校驗規則
                //校驗規則要求必須是%2d，很奇怪的校驗
                sb.append(String.format("%2d ", blocks[row][col]));
            }
            sb.append("\n");
        }
        return sb.toString();
    }

    public static void main(String[] args) {
//         unit tests (not graded)
//         int[][] test = { { 0, 1}, {2,3 }};
//         Board b = new Board(test);
//         System.out.println(b);
//         System.out.println(b.hamming());
//         System.out.println(b.manhattan());
    }
}

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.MinPQ;
import edu.princeton.cs.algs4.Stack;
import edu.princeton.cs.algs4.StdOut;
/**
 * @author evasean www.cnblogs.com/evasean/
 */
public class Solver {
    
    private SearchNode currentNode;
    private SearchNode twincurrentNode;
    private Stack<Board> solution;
    
    private class SearchNode implements Comparable<SearchNode>{
        public Board board;
        public int moves;
        public SearchNode preSearchNode;
        
        public final int priority;
        
        public SearchNode(Board inboard, SearchNode inPreSearchNode){
            board = inboard;
            preSearchNode = inPreSearchNode;
            if(inPreSearchNode == null) moves = 0;    
            else moves = inPreSearchNode.moves + 1;
            priority = moves + board.manhattan();
        }

        @Override
        public int compareTo(SearchNode o) {
            return Integer.compare(this.priority, o.priority);
        }
    }
    
    
    public Solver(Board initial) {
        // find a solution to the initial board (using the A* algorithm)
        if(initial == null)
            throw new IllegalArgumentException("Constructor argument Board is null!");
        currentNode = new SearchNode(initial,null);
        twincurrentNode = new SearchNode(initial.twin(),null);
        MinPQ<SearchNode> priorityQueue = new MinPQ<SearchNode>();
        MinPQ<SearchNode> twinPriorityQueue = new MinPQ<SearchNode>();
        priorityQueue.insert(currentNode);
        twinPriorityQueue.insert(twincurrentNode);
        while(true){
            currentNode = priorityQueue.delMin();
            if(currentNode.board.isGoal()) break;
            putNeighBorsIntoPQ(currentNode,priorityQueue);
            
            twincurrentNode = twinPriorityQueue.delMin();
            if(twincurrentNode.board.isGoal()) break;
            putNeighBorsIntoPQ(twincurrentNode,twinPriorityQueue);
        }
    }
    
    private void putNeighBorsIntoPQ(SearchNode searchNode, MinPQ<SearchNode> pq){
        Iterable<Board> neighbors = searchNode.board.neighbors();
        for(Board neighbor : neighbors){
            //只有在當前搜索節點的鄰居們的borad不與當前節點的preSearchNode的borad相同
            //才將該鄰居放入優先隊列
            
            if(searchNode.preSearchNode==null || !neighbor.equals(searchNode.preSearchNode.board))
                pq.insert(new SearchNode(neighbor,searchNode));
        }
    }

    public boolean isSolvable() {
        // is the initial board solvable?
        return currentNode.board.isGoal();
    }

    public int moves() {
        // min number of moves to solve initial board; -1 if unsolvable
        if(currentNode.board.isGoal())
            return currentNode.moves;
        else
            return -1;
    }

    public Iterable<Board> solution() {
        // sequence of boards in a shortest solution; null if unsolvable
        if(currentNode.board.isGoal()){
            solution = new Stack<Board>();
            SearchNode node = currentNode;
            while(node != null){
                solution.push(node.board);
                node = node.preSearchNode;
            }
            return solution;
        }else
            return null;
    }

    public static void main(String[] args) {
        // solve a slider puzzle (given below)
        // create initial board from file
//        In in = new In(args[0]);
        In in = new In("8puzzle/puzzle3x3-unsolvable.txt"); //本地測試之用
        int n = in.readInt();
        int[][] blocks = new int[n][n];
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                blocks[i][j] = in.readInt();
        Board initial = new Board(blocks);

        // solve the puzzle
        Solver solver = new Solver(initial);

        // print solution to standard output
        if (!solver.isSolvable())
            StdOut.println("No solution possible");
        else {
            StdOut.println("Minimum number of moves = " + solver.moves());
            for (Board board : solver.solution())
                StdOut.println(board);
        }
    }
}