普利斯顿算法（一）week4 8 puzzle

Board类，该类整体比较简单，不涉及较难的算法，主要是数据结构和方法的构建。

细节：

• 曼哈顿距离：（x1, y1）与 (x2, y2) 之间的曼哈顿距离为|x1 - x2| + |y1 - y2|，计算曼哈顿和汉明距离时要遍历所有格子，对于空格跳过即可。例如下图左侧方格右下角的5，与goal中5的曼哈顿距离为3-2+3-2 = 2，在代码中要用数组索引求得：i = 2(board行数), j = 2(board列数), (5-1) / 3 = 1(goal 中的行数), (5-1)/3 = 1(goal中的列数)，曼哈顿距离即为i - 1 + j - 1 = 2。
  - 在实现neighbor和twin方法时，要新开辟一段内存空间，不能在原本空间上进行操作。

import java.util.ArrayList;

public class Board {
   
    private final int[][] tiles; 
    private final int N;
    private int getN() {
   
        return N;
    }

    // create a board from an n-by-n array of tiles,
    // where tiles[row][col] = tile at (row, col)
    public Board(int[][] tiles) {
   
        if (tiles == null)
            throw new IllegalArgumentException("tiles is null");
        N = tiles.length;
        this.tiles = new int[N][N];
        for (int i = 0; i < N; ++i) {
   
            for (int j = 0; j < N; ++j) {
   
                this.tiles[i][j] = tiles[i][j];
            }
        }
    }

    // string representation of this board
    public String toString() {
   
        String s = new String();
        s += N;
        s += "\n";
        for (int i = 0; i < N; ++i) {
   
            for (int j = 0; j < N; ++j) {
   
                s += (this.tiles[i][j] + " ");
            }
            s += "\n";
        }
        return s;
    }

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

    // number of tiles out of place
    public int hamming() {
   
        int hamming = 0;
        for (int i = 0; i < N; ++i) {
   
            for (int j = 0; j < N; ++j) {
   
                if (tiles[i][j] != 0 && tiles[i][j] != i * N + j + 1)  //过滤空格，tile[i][j]的值不等于应有的值时。
                    hamming++;
            }
        }
        return hamming;
    }

    // sum of Manhattan distances between tiles and goal
    public int manhattan() {
   
        int manhattan = 0;
        for (int i = 0; i < N; ++i) {
   
            for (int j = 0; j < N; ++j) {
   
                if (tiles[i][j] != 0 && tiles[i][j] != i * N + j + 1