Improved solution

Author: proton

week4/priority-queues/assignment-8-puzzle/Board.java

@@ -1,3 +1,5 @@
+import java.util.ArrayList;
+
 public class Board {
   private int n;
   private int[][] tiles;
@@ -15,7 +17,7 @@ public Board(int[][] tiles) {
 
   // string representation of this board
   public String toString() {
-    String s = new String();
+    String s = "";
 
     s = s.concat(dimension() + "\n");
 
@@ -56,8 +58,8 @@ public int manhattan() {
       int x = (v - 1) / n;
       int y = (v - 1) % n;
 
-      int xd = Math.abs(x - j);
-      int xy = Math.abs(y - i);
+      int xd = Math.abs(x - i);
+      int xy = Math.abs(y - j);
 
       cnt += xd + xy;
     }
@@ -83,6 +85,8 @@ public boolean equals(Object y) {
 
     Board other = (Board) y;
     if (dimension() != other.dimension()) return false;
+    if (hamming()   != other.hamming())   return false;
+    if (manhattan() != other.manhattan()) return false;
 
     return true;
 
@@ -97,12 +101,34 @@ public boolean equals(Object y) {
 
   // all neighboring boards
   public Iterable<Board> neighbors() {
-    return null;
+    int emptyX = -1;
+    int emptyY = -1;
+    for (int i = 0; i < dimension(); ++i)
+    for (int j = 0; j < dimension(); ++j) {
+      if (tiles[i][j] == 0) {
+        emptyX = i;
+        emptyY = j;
+        break;
+      }
+    }
+
+    ArrayList<Board> neighbors = new ArrayList<Board>();
+    if (emptyX > 0) neighbors.add(neighbour(emptyX, emptyY, -1,  0));
+    if (emptyX < 2) neighbors.add(neighbour(emptyX, emptyY,  1,  0));
+    if (emptyY > 0) neighbors.add(neighbour(emptyX, emptyY,  0, -1));
+    if (emptyY < 2) neighbors.add(neighbour(emptyX, emptyY,  0,  1));
+    return neighbors;
   }
 
   // a board that is obtained by exchanging any pair of tiles
   public Board twin() {
-    return null;
+    Board twinBoard = new Board(tiles);
+
+    if (tiles[0][0] == 0) twinBoard.swap(0, 1, 1, 1);
+    else if (tiles[0][1] == 0) twinBoard.swap(0, 0, 1, 0);
+    else twinBoard.swap(0, 0, 0, 1);
+
+    return twinBoard;
   }
 
   // unit testing (not graded)
@@ -113,4 +139,17 @@ public static void main(String[] args) {
   private int goalAt(int i, int j) {
     return i * n + j + 1;
   }
+
+  private Board neighbour(int x, int y, int dx, int dy) {
+    swap(x, y, x + dx, y + dy);
+    Board board = new Board(tiles);
+    swap(x, y, x + dx, y + dy);
+    return board;
+  }
+
+  private void swap(int i, int j, int x, int y) {
+    int tmp = tiles[i][j];
+    tiles[i][j] = tiles[y][x];
+    tiles[x][y] = tmp;
+  }
 }

week4/priority-queues/assignment-8-puzzle/Solver.java

@@ -1,29 +1,131 @@
+import java.util.Comparator;
+
 import edu.princeton.cs.algs4.In;
 import edu.princeton.cs.algs4.StdOut;
+import edu.princeton.cs.algs4.Stack;
+import edu.princeton.cs.algs4.MinPQ;
 
 public class Solver {
+  private Board initial;
+  private int moves;
+  private boolean solvable;
+  private Stack<Board> solution;
+
+  // search node
+  private static class Node {
+    Board board;
+    int moves;
+    int priority;
+    Node prev;
+  }
+
   // find a solution to the initial board (using the A* algorithm)
   public Solver(Board initial) {
     if (initial == null) {
       throw new IllegalArgumentException("initial argument to Solver constructor is null");
     }
+    this.initial = initial;
+    solve();
   }
 
   // is the initial board solvable? (see below)
   public boolean isSolvable() {
-    return false;
+    return this.solvable;
   }
 
   // min number of moves to solve initial board; -1 if unsolvable
   public int moves() {
-    // Return -1 in moves() if the board is unsolvable.
-    return -1;
+    return this.moves;
   }
 
   // sequence of boards in a shortest solution; null if unsolvable
   public Iterable<Board> solution() {
-    // Return null in solution() if the board is unsolvable.
-    return null;
+    return this.solution;
+  }
+
+  private void solve() {
+    this.moves = -1;
+    this.solvable = true;
+    this.solution = new Stack<Board>();
+
+    MinPQ<Node> pq = initPQ(initial);
+    MinPQ<Node> twinpq = initPQ(initial.twin());
+
+    while (true) {
+      Node searchNode = pq.delMin();
+      Node prevNode = searchNode.prev;
+      Board searchBoard = searchNode.board;
+
+      if (searchBoard.isGoal()) {
+        this.solvable = true;
+        this.moves = searchNode.moves;
+        this.solution = findPath(searchNode);
+        break;
+      }
+
+      for (Board b : searchBoard.neighbors()) {
+        if (prevNode == null || !prevNode.board.equals(b)) {
+          Node temp = new Node();
+          temp.prev = searchNode;
+          temp.board = b;
+          temp.moves = searchNode.moves + 1;
+          temp.priority = temp.moves + b.manhattan();
+          pq.insert(temp);
+        }
+      }
+
+      Node twinSearchNode = twinpq.delMin();
+      Node twinPrevNode = twinSearchNode.prev;
+      Board twinSearchBoard = twinSearchNode.board;
+
+      if (twinSearchBoard.isGoal()) {
+        this.solvable = false;
+        break;
+      }
+
+      for (Board b : twinSearchBoard.neighbors()) {
+        if (twinPrevNode == null || twinPrevNode.board.equals(b)) {
+          Node temp = new Node();
+          temp.prev = twinSearchNode;
+          temp.board = b;
+          temp.moves = twinSearchNode.moves + 1;
+          temp.priority = temp.moves + b.manhattan();
+          twinpq.insert(temp);
+        }
+      }
+    }
+  }
+
+  private Comparator<Node> priority() {
+    return new ByPriority();
+  }
+
+  private class ByPriority implements Comparator<Node> {
+    public int compare(Node n1, Node n2) {
+      return n1.priority > n2.priority ? 1 : n1.priority < n2.priority ? -1 : 0;
+    }
+  }
+
+  private MinPQ<Node> initPQ(Board root) {
+    Node rootNode = new Node();
+    rootNode.board = root;
+    rootNode.moves = 0;
+    rootNode.priority = root.manhattan();
+    rootNode.prev = null;
+
+    MinPQ<Node> pq = new MinPQ<Node>(priority());
+    pq.insert(rootNode);
+    return pq;
+  }
+
+  private Stack<Board> findPath(Node leaf) {
+    Stack<Board> path = new Stack<Board>();
+    Node temp = leaf;
+    while (temp != null) {
+      path.push(temp.board);
+      temp = temp.prev;
+    }
+    return path;
   }
 
   // test client (see below)
@@ -53,5 +155,4 @@ public static void main(String[] args) {
       }
     }
   }
-
 }