cost, equality

Author: jamesrcounts

src/main/java/org/teachingkidsprogramming/section08tdd/PuzzleBoard.java

@@ -13,17 +13,26 @@
 public class PuzzleBoard extends JPanel {
   private static final String completed        = "Batgirl.png";
   private static final long   serialVersionUID = -3592444274530147326L;
-  private final List<Tile> tiles;
-  private final Point[]    positions;
-  private       boolean    done;
+  private final List<Tile>        tiles;
+  private final Point[]           positions;
+  private final List<PuzzleBoard> history;
+  private       boolean           done;
 
   public PuzzleBoard() {
     this.positions = createPositions();
     this.tiles = createTiles(shuffled(this.positions));
-
+    this.history = new ArrayList<>();
   }
 
   public PuzzleBoard(Point[] positions, List<Tile> tiles) {
+    this(positions, tiles, new ArrayList<PuzzleBoard>());
+  }
+
+  public PuzzleBoard(PuzzleBoard puzzle) {
+    this(puzzle.positions, puzzle.tiles, puzzle.history);
+  }
+
+  public PuzzleBoard(Point[] positions, List<Tile> tiles, List<PuzzleBoard> history) {
     this.positions = new Point[positions.length];
     for (int i = 0; i < positions.length; i++) {
       this.positions[i] = new Point(positions[i]);
@@ -34,14 +43,18 @@ public PuzzleBoard(Point[] positions, List<Tile> tiles) {
       Tile t = tiles.get(i);
       this.tiles.add(i, new Tile(t));
     }
-  }
 
-  public PuzzleBoard(PuzzleBoard puzzle) {
-    this(puzzle.positions, puzzle.tiles);
+    if (history == null) history = new ArrayList<>();
+
+    this.history = new ArrayList<>(history.size());
+    for (int i = 0; i < history.size(); i++) {
+      PuzzleBoard b = history.get(i);
+      this.history.add(i, new PuzzleBoard(b));
+    }
   }
 
-  private static List<Point> shuffled(Point[] positions) {
-    List<Point> s = Arrays.asList(positions);
+  public static List<Point> shuffled(Point[] positions) {
+    List<Point> s = new ArrayList<>(Arrays.asList(positions));
     Collections.shuffle(s);
     return s;
   }
@@ -189,42 +202,11 @@ public PuzzleBoard useMove(TileMove move) {
     Tile s = c.getPieceFromPosition(move.getSource());
     s.moveTo(c.positions[move.getTarget()]);
     s.teleport();
+    c.history.add(new PuzzleBoard(this));
 
     return c;
   }
 
-  /**
-   * Estimate the cost of solving the puzzle if this is the next step in the
-   * solution.
-   *
-   * @param history
-   *     All the steps we have already visited.
-   * @return The estimated cost
-   */
-  public int estimateCost(List<PuzzleBoard> history) {
-
-    // see
-    // https://jdanger.com/solving-8-puzzle-with-artificial-intelligence.html
-    // for ruby implementation
-
-    // We know the actual cost will be at least 1, because we must
-    // make at least one move to get to this board.
-    int cost = 1;
-
-    // Each tile that is in the wrong position will require at least
-    // one move to get it in the right position (and possibly more than
-    // 1). So add 1 to the estimate for every misplaced tile.
-    cost += this.countMisplaced();
-
-    // If we have visited this board before, then we are actually
-    // going backward. We will need at least one more move after
-    // this one to move forward to the solution. So add one more move
-    // to the estimate for every time we have visited this board.
-    cost += this.timesVisited(history);
-
-    return cost;
-  }
-
   @Override
   public boolean equals(Object o) {
     if (this == o)
@@ -234,7 +216,7 @@ public boolean equals(Object o) {
 
     PuzzleBoard that = (PuzzleBoard) o;
 
-    return tiles.equals(that.tiles);
+    return this.toString().equals(that.toString());
 
   }
 
@@ -243,17 +225,6 @@ public int hashCode() {
     return tiles.hashCode();
   }
 
-  private int timesVisited(List<PuzzleBoard> history) {
-    int visited = 0;
-    for (PuzzleBoard puzzleBoard : history) {
-      if (this.equals(puzzleBoard)) {
-        visited++;
-      }
-    }
-
-    return visited;
-  }
-
   public Tile getPieceFromPosition(int source) {
     Point position = this.positions[source];
     for (Tile tile : this.tiles) {
@@ -264,4 +235,24 @@ public Tile getPieceFromPosition(int source) {
 
     return null;
   }
+
+  public List<PuzzleBoard> getHistory() {
+    return new ArrayList<>(this.history);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder builder = new StringBuilder();
+    builder.append("[ ");
+    for(Tile t : this.tiles){
+      builder.append(t.toString()).append(", ");
+    }
+    builder.append("]");
+
+    return builder.toString();
+  }
+
+  public boolean isVisited() {
+    return this.history.contains(this);
+  }
 }

src/main/java/org/teachingkidsprogramming/section08tdd/PuzzleSolver.java

@@ -7,7 +7,6 @@
 
 public class PuzzleSolver implements Runnable {
   private final PuzzleBoard board;
-  private final List<PuzzleBoard> history = new ArrayList<>();
 
   public PuzzleSolver(PuzzleBoard board) {
     this.board = board;
@@ -50,7 +49,6 @@ private void update(final PuzzleBoard puzzle) {
   }
 
   private void solve(PuzzleBoard puzzle) {
-    this.copyToHistory(puzzle);
 
     int minimumCost = Integer.MAX_VALUE;
     TileMove min = null;
@@ -64,8 +62,14 @@ private void solve(PuzzleBoard puzzle) {
 
       // otherwise apply the move to generate a new board
       PuzzleBoard next = puzzle.useMove(tileMove);
+
+      // see if we have visited this board before:
+      if (next.isVisited()){
+        continue;
+      }
+
       // estimate the cost to reach the goal by going through the new board
-      int estimate = estimateSolvingCost(next, this.history);
+      int estimate = estimateCost(next);
 
       // if the cost is the smallest we've seen so far
       if (estimate < minimumCost) {
@@ -87,10 +91,6 @@ private void solve(PuzzleBoard puzzle) {
     }
   }
 
-  private int estimateSolvingCost(PuzzleBoard next, List<PuzzleBoard> history) {
-    return next.estimateCost(new ArrayList<>(history));
-  }
-
   // 0: can move down (to #3) or right (to #1)
   // 1: can move left (to #0), down (to #4), or right (to #2)
   // 2: can move left (to #1) or down (to #5)
@@ -129,10 +129,6 @@ private List<TileMove> createMoves() {
     return moves;
   }
 
-  private void copyToHistory(PuzzleBoard puzzle) {
-    this.history.add(new PuzzleBoard(puzzle));
-  }
-
   private boolean animate(PuzzleBoard puzzle) {
     List<Tile> tiles = puzzle.getTiles();
     for (Tile tile : tiles) {
@@ -160,7 +156,7 @@ public static int distance(Point start, Point end) {
     return Math.abs(start.x - end.x) + Math.abs(start.y - end.y);
   }
 
-  public static int distance(PuzzleBoard start) {
+  public static int estimateRemainingMoves(PuzzleBoard start) {
     int result = 0;
     for (Tile tile : start.getTiles()) {
       int goalIndex = tile.getCorrectPositionIndex();
@@ -170,4 +166,16 @@ public static int distance(PuzzleBoard start) {
     }
     return result;
   }
+
+  public static int estimateCost(PuzzleBoard board) {
+    // The cost of this solving the puzzle using this is at least the number of moves it took to get to this
+    // board
+    int cost = board.getHistory().size();
+
+    // We estimate that the cost of solving the puzzle from here will be related to the number of moves needed
+    // to get the tiles into the right positions, so we add the estimate to the actual cost
+    cost += estimateRemainingMoves(board);
+
+    return cost;
+  }
 }

src/main/java/org/teachingkidsprogramming/section08tdd/Tile.java

@@ -55,6 +55,24 @@ public void step() {
     this.position = new Point(x, y);
   }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    Tile tile = (Tile) o;
+
+    return correctPositionIndex == tile.correctPositionIndex && position.equals(tile.position);
+
+  }
+
+  @Override
+  public int hashCode() {
+    int result = position.hashCode();
+    result = 31 * result + correctPositionIndex;
+    return result;
+  }
+
   private int stepVertical(int size) {
     if (this.position.y < this.target.y) {
       return this.position.y + size;
@@ -63,6 +81,7 @@ private int stepVertical(int size) {
       return this.position.y - size;
     }
     return this.position.y;
+
   }
 
   private int stepHorizontal(int size) {
@@ -94,4 +113,9 @@ public int getCorrectPositionIndex() {
   public Point getPosition() {
     return position;
   }
+
+  @Override
+  public String toString() {
+    return "{ " + this.position.x + ", " + this.position.y + " }";
+  }
 }

src/test/java/org/teachingextensions/logo/tests/PuzzleBoardTest.java

@@ -1,9 +1,13 @@
 package org.teachingextensions.logo.tests;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import java.awt.Point;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import org.junit.Test;
@@ -59,4 +63,38 @@ public void invalidMoveTest() {
     assertFalse(b.isValidMove(move));
   }
 
+  @Test
+  public void toStringTest(){
+    assertEquals("[ { 35, 35 }, { 35, 162 }, { 35, 289 }, { 162, 35 }, { 162, 162 }, { 162, 289 }, { 289, 35 }, { 289, 162 }, ]", getSolvedBoard().toString());
+  }
+
+  @Test
+  public void equalityTest(){
+    Point[] positions = PuzzleBoard.createPositions();
+    List<Tile> tiles = PuzzleBoard.createTiles(positions);
+    PuzzleBoard a = new PuzzleBoard(positions, tiles);
+    List<PuzzleBoard> history = new ArrayList<>();
+    history.add(a);
+    PuzzleBoard b = new PuzzleBoard(positions, tiles, history);
+    assertTrue(a.equals(b));
+  }
+
+  @Test
+  public void inequalityTest(){
+    Point[] positions = PuzzleBoard.createPositions();
+    List<Tile> tiles = PuzzleBoard.createTiles(positions);
+    PuzzleBoard a = new PuzzleBoard(positions, tiles);
+
+    List<PuzzleBoard> history = new ArrayList<>();
+    history.add(a);
+
+    Point[] locations = PuzzleBoard.createPositions();
+    Point[] array = new Point[locations.length];
+    List<Point> l = PuzzleBoard.shuffled(locations);
+    l.toArray(array);
+    List<Tile> t = PuzzleBoard.createTiles(l);
+    PuzzleBoard b = new PuzzleBoard(PuzzleBoard.createPositions(), t, history);
+    assertFalse(a.equals(b));
+  }
+
 }

src/test/java/org/teachingextensions/logo/tests/PuzzleSolverTest.java

@@ -6,6 +6,7 @@
 import org.teachingkidsprogramming.section08tdd.Tile;
 
 import java.awt.*;
+import java.util.ArrayList;
 import java.util.List;
 
 import static org.junit.Assert.assertEquals;
@@ -56,14 +57,14 @@ public void manhattanDistanceFromEightToZeroTest() {
 
   @Test
   public void distanceFromSolvedToSolved() {
-    PuzzleBoard solved = getSolvedPuzzle();
-    assertEquals(0, PuzzleSolver.distance(solved));
+    PuzzleBoard solved = getSolvedPuzzle(null);
+    assertEquals(0, PuzzleSolver.estimateRemainingMoves(solved));
   }
 
-  private PuzzleBoard getSolvedPuzzle() {
+  private PuzzleBoard getSolvedPuzzle(List<PuzzleBoard> history) {
     Point[] positions = PuzzleBoard.createPositions();
     List<Tile> tiles = PuzzleBoard.createTiles(positions);
-    return new PuzzleBoard(positions, tiles);
+    return new PuzzleBoard(positions, tiles, history);
   }
 
   @Test
@@ -78,7 +79,7 @@ public void distanceForPuzzleWithOneMisplacedTile() {
     List<Tile> tiles = PuzzleBoard.createTiles(positions);
     PuzzleBoard b = new PuzzleBoard(PuzzleBoard.createPositions(), tiles);
     int expected = PuzzleSolver.distance(positions[8], positions[7]);
-    assertEquals(expected, PuzzleSolver.distance(b));
+    assertEquals(expected, PuzzleSolver.estimateRemainingMoves(b));
   }
 
   @Test
@@ -104,7 +105,34 @@ public void distanceForPuzzleWithSeveralMisplacedTiles() {
 
 
     PuzzleBoard b = new PuzzleBoard(PuzzleBoard.createPositions(), tiles);
-    assertEquals(expected, PuzzleSolver.distance(b));
+    assertEquals(expected, PuzzleSolver.estimateRemainingMoves(b));
+  }
+
+  @Test
+  public void solutionHasNoCostTest() {
+    PuzzleBoard b = getSolvedPuzzle(null);
+    assertEquals(0, PuzzleSolver.estimateCost(b));
+  }
+
+  @Test
+  public void solutionHasHistoryCost() {
+    PuzzleBoard b = getSolvedPuzzle(null);
+    List<PuzzleBoard> history = new ArrayList<>();
+    history.add(b);
+    history.add(b);
+    history.add(b);
+    PuzzleBoard c = getSolvedPuzzle(history);
+    assertEquals(3, PuzzleSolver.estimateCost(c));
+  }
+
+  @Test
+  public void unsolvedPuzzleHasMovementCost() {
+    Point[] positions = PuzzleBoard.createPositions();
+    positions = swap(positions, 7, 8);
+    List<Tile> tiles = PuzzleBoard.createTiles(positions);
+
+    PuzzleBoard board = new PuzzleBoard(PuzzleBoard.createPositions(), tiles);
+    assertEquals(127, PuzzleSolver.estimateCost(board));
   }
 
   private Point[] swap(Point[] positions, int i, int j) {