算法导论第四版学习——习题四8 Puzzle

题目正文：

http://coursera.cs.princeton.edu/algs4/assignments/8puzzle.html

作业难点：

1、如何验证Puzzle是否可解？题目中有提示，如果相邻两个格子交换后得到的“Twin Puzzle”进行求解，如果Twin有解那么原始Puzzle就无解。

作业技巧：

1、checklist提到把Twin Puzzle和Puzzle放在一个Priority Queue中，其实就是在设计自己的Node数据结构的时候加一个boolean类型标识是否twin就好了

2、别忘了Equal的实现要素，首先是否为空、其次是否类型一致、再其次维度是否一致、最后逐个比较。

代码参考：

（这是我自己亲测100分的答案，不代表写得最好，请在自己实在完成不了的时候再看，不然的话做这个题目的意义一点都没有）

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;

import java.util.Stack;


public class Board {
    private int ngrid;
    private char[] board;
    private int hammingCache;
    private int manhattanCache;

    public Board(int[][] blocks) {
        ngrid = blocks.length;

        if (ngrid < 2) {
            throw new NullPointerException();
        }

        board = new char[ngrid * ngrid];
        hammingCache = 0;
        manhattanCache = 0;

        for (int i = 0; i < ngrid; i++) {
            for (int j = 0; j < ngrid; j++) {
                int currentValue = blocks[i][j];
                board[(i * ngrid) + j] = (char) currentValue;

                if (currentValue != 0) {
                    if (currentValue != ((i * ngrid) + j + 1)) {
                        hammingCache++;
                    }

                    int col = (currentValue - 1) % ngrid;
                    int row = (currentValue - col - 1) / ngrid;
                    // StdOut.println("v:"+currentValue+"r:"+row+"c:"+col);
                    manhattanCache += (((col > j) ? (col - j) : (j - col)) +
                    ((row > i) ? (row - i) : (i - row)));
                }
            }
        }
    }

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

    public int hamming() // number of blocks out of place
     {
        return hammingCache;
    }

    public int manhattan() // sum of Manhattan distances between blocks and goal
     {
        return manhattanCache;
    }

    public boolean isGoal() // is this board the goal board?
     {
        return hammingCache == 0;
    }

    public Board twin() // a board that is obtained by exchanging any pair of blocks
     {
        int[][] twin = new int[ngrid][ngrid];

        for (int i = 0; i < ngrid; i++) {
            for (int j = 0; j < ngrid; j++) {
                twin[i][j] = (int) board[(i * ngrid) + j];
            }
        }

        if ((twin[0][0] == 0) || (twin[0][1] == 0)) {
            swap(twin, 1, 0, 1, 1);
        } else {
            swap(twin, 0, 0, 0, 1);
        }

        return new Board(twin);
    }

    public boolean equals(Object y) // does this board equal y?
     {
        if (y == this) {
            return true;
        }

        if (y == null) {
            return false;
        }

        if (y.getClass() != this.getClass()) {
            return false;
        }

        Board that = (Board) y;
        if (that.dimension() != ngrid) return false;
        for (int i = 0; i < (ngrid * ngrid); i++) {
            if (this.board[i] != that.board[i]) {
                return false;
            }
        }

        return true;
    }

    public Iterable<Board> neighbors() // all neighboring boards
     {
        int blankRow = 0;
        int blankCol = 0;
        Stack<Board> neighbours = new Stack<Board>();

        int[][] clone = new int[ngrid][ngrid];

        for (int i = 0; i < ngrid; i++) {
            for (int j = 0; j < ngrid; j++) {
                clone[i][j] = (int) board[(i * ngrid) + j];

                if (clone[i][j] == 0) {
                    blankRow = i;
                    blankCol = j;
                }
            }
        }

        if (blankCol != 0) {
            swap(clone, blankRow, blankCol - 1, blankRow, blankCol);
            neighbours.push(new Board(clone));
            swap(clone, blankRow, blankCol - 1, blankRow, blankCol);
        }

        if (blankCol != (ngrid - 1)) {
            swap(clone, blankRow, blankCol + 1, blankRow, blankCol);
            neighbours.push(new Board(clone));
            swap(clone, blankRow, blankCol + 1, blankRow, blankCol);
        }

        if (blankRow != 0) {
            swap(clone, blankRow - 1, blankCol, blankRow, blankCol);
            neighbours.push(new Board(clone));
            swap(clone, blankRow - 1, blankCol, blankRow, blankCol);
        }

        if (blankRow != (ngrid - 1)) {
            swap(clone, blankRow + 1, blankCol, blankRow, blankCol);
            neighbours.push(new Board(clone));
        }

        return neighbours;
    }

    private void swap(int[][] array, int i, int j, int a, int b) {
        int temp = array[i][j];
        array[i][j] = array[a][b];
        array[a][b] = temp;
    }

    public String toString() // string representation of this board (in the output format specified below)
     {
        StringBuilder s = new StringBuilder();
        s.append(ngrid + "\n");
        for (int i = 0; i < ngrid; i++) {
            for (int j = 0; j < ngrid; j++) {
                s.append(String.format("%2d ", (int) board[(i * ngrid) + j]));
            }

            s.append("\n");
        }

        return s.toString();
    }

    public static void main(String[] args) // unit tests (not graded)
     {
        // read in the board specified in the filename
        In in = new In(args[0]);
        int n = in.readInt();
        int[][] tiles = new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                tiles[i][j] = in.readInt();
            }
        }

        // solve the slider puzzle
        Board initial = new Board(tiles);
        StdOut.printf("hamming:%d manhattan:%d \n", initial.hamming(),
            initial.manhattan());
        StdOut.println("dim:" + initial.dimension());
        StdOut.println(initial.toString());
        StdOut.println("goal:" + initial.isGoal());
        StdOut.println("twin:\n" + initial.twin().toString());

        StdOut.println("neighbours:");

        for (Board s : initial.neighbors()) {
            StdOut.println(s.toString());
        }
    }
}

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.MinPQ;
import edu.princeton.cs.algs4.StdOut;

import java.util.Stack;


public class Solver {
    private boolean solvable;
    private GameNode originLast;

    public Solver(Board initial) // find a solution to the initial board (using the A* algorithm)
     {
        if (initial == null) {
            throw new NullPointerException();
        }

        solvable = true;

        MinPQ<GameNode> queue = new MinPQ<GameNode>();

        queue.insert(new GameNode(initial, null, 0, false));
        queue.insert(new GameNode(initial.twin(), null, 0, true));

        while (!queue.isEmpty()) {
            GameNode processed = queue.delMin();

            if (!processed.isTwin) {
                originLast = processed;
            }

            if (processed.boardValue.isGoal()) {
                if (processed.isTwin) {
                    solvable = false;
                }

                break;
            }

            for (Board neighbor : processed.boardValue.neighbors()) {
                if ((processed.prev == null) ||
                        !processed.prev.boardValue.equals(neighbor)) {
                    queue.insert(new GameNode(neighbor, processed,
                            processed.moves + 1, processed.isTwin));
                }
            }
        }
    }

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

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

    public Iterable<Board> solution() // sequence of boards in a shortest solution; null if unsolvable
     {
        if (!isSolvable()) {
            return null;
        }

        Stack<Board> solutions = new Stack<Board>();
        GameNode current = originLast;

        while (current.prev != null) {
            solutions.push(current.boardValue);
            current = current.prev;
        }

        solutions.push(current.boardValue);

        Stack<Board> solutions2 = new Stack<Board>();

        while (!solutions.empty()) {
            solutions2.push(solutions.pop());
        }

        return solutions2;
    }

    public static void main(String[] args) {
        // create initial board from file
        In in = new In(args[0]);
        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);
        }
    }

    private class GameNode implements Comparable<GameNode> {
        private Board boardValue;
        private GameNode prev;
        private int moves;
        private boolean isTwin;

        public GameNode(Board current, GameNode prev, int moves, boolean isTwin) {
            this.boardValue = current;
            this.prev = prev;
            this.moves = moves;
            this.isTwin = isTwin;
        }

        public int compareTo(GameNode that) {
            int priority1 = this.boardValue.manhattan() + this.moves;
            int priority2 = that.boardValue.manhattan() + that.moves;

            if (priority1 == priority2) {
                return 0;
            } else if (priority1 > priority2) {
                return 1;
            } else {
                return -1;
            }
        }
    }
}