fixed gap calculation

Author: sebastianhaeni

src/main/java/ch/sebastianhaeni/pancake/IterativeSolver.java

@@ -16,8 +16,9 @@ private IterativeSolver() {
 
  public static void main(String[] args) {
 
- Node root = new Node(Generator.alternate(20));
-// Node root = new Node(Generator.random(40));
+ Node root = new Node(Generator.alternate(14));
+// Node root = new Node(Generator.alternate(20));
+// Node root = new Node(Generator.random(25));
 
  System.out.format("Solving a pancake pile of height %d.\n", root.getState().length);
 
@@ -33,12 +34,13 @@ private static void solve(Node root) {
  NODES.push(root);
  NODES.peek().nextNodes();
 
- int bound = root.getDistance();
+ int bound = root.getGap();
+ System.out.println("Searching with bound " + bound);
  int candidateBound = Integer.MAX_VALUE;
 
- while (NODES.peek().gap() > 0) {
- if (NODES.peek().getDistance() + NODES.peek().getDepth() > bound) {
-  int stateBound = NODES.peek().getDepth() + NODES.peek().getDistance();
+ while (NODES.peek().getGap() > 0) {
+ int stateBound = NODES.peek().getGap() + NODES.peek().getDepth();
+ if (stateBound > bound) {
  if (stateBound < candidateBound) {
  candidateBound = stateBound;
  }

src/main/java/ch/sebastianhaeni/pancake/ParallelSolver.java

@@ -11,7 +11,8 @@ public final class ParallelSolver {
  public static final int CONTROLLER_RANK = 0;
  public static final int[] EMPTY_BUFFER = new int[0];
 
- private static final int[] INITIAL_STATE = Generator.random(30);
+// private static final int[] INITIAL_STATE = Generator.random(30);
+ private static final int[] INITIAL_STATE = Generator.alternate(14);
 /*
  private static final int[] INITIAL_STATE = {7, 13, 21, 4, 16, 31, 30, 35, 40, 23, 8, 19, 33, 24, 38, 28, 29, 14, 26, 6, 25, 32, 1, 3, 5, 22, 37, 9, 20, 2, 10, 34, 18, 17, 11, 27, 12, 15, 39, 36}; // 40
  private static final int[] INITIAL_STATE = {3, 4, 2, 5, 1}; // 5

src/main/java/ch/sebastianhaeni/pancake/model/Node.java

@@ -25,10 +25,9 @@ public class Node implements Serializable {
  private final Stack<Node> children = new Stack<>();
 
  /**
- * Pancake pile size.
+ * Gap heuristic value.
  */
- private final int size;
- private int distance;
+ private final int gap;
 
  public Node(int[] state) {
  this(state, 0);
@@ -37,62 +36,75 @@ public Node(int[] state) {
  private Node(int[] state, int depth) {
  this.state = state;
  this.depth = depth;
- this.size = state.length;
- this.distance = gap();
+ this.gap = gap();
  }
 
- public Node(int[] state, int depth, int distance) {
+ public Node(int[] state, int depth, int gap) {
  this.state = state;
  this.depth = depth;
- this.size = state.length;
- this.distance = distance;
+ this.gap = gap;
  }
 
- public int gap() {
+ private int gap() {
  int gap = 0;
 
- for (int i = 0; i < size - 1; i++) {
- if (state[i] - state[i + 1] != -1) {
+ for (int i = 1; i < state.length; i++) {
+ if (Math.abs(state[i] - state[i - 1]) > 1) {
  gap++;
  }
  }
  return gap;
  }
 
+ /**
+ * Expands this node.
+ */
  public void nextNodes() {
- for (int i = 2; i < size; i++) {
- if (state[i] - state[0] == 1) {
- children.push(flip(i, distance - 1));
- } else {
- children.push(flip(i, distance));
+ for (int i = 2; i < state.length; i++) {
+ int gap = this.gap;
+
+ int currentDiff = Math.abs(state[i] - state[i - 1]);
+ int newDiff = Math.abs(state[i] - state[0]);
+
+ if (currentDiff != 1 && newDiff == 1) {
+ gap -= 1;
+ } else if (currentDiff == 1 && newDiff != 1) {
+ gap += 1;
  }
+
+ children.push(flip(i, gap));
  }
  }
 
  /**
  * Flips the prefix at the defined flip position.
  *
  * @param flipPosition the position where the state shall be reversed
- * @param distance predetermined optimistic distance for the new nodes
+ * @param gap  predetermined optimistic gap for the new node
  * @return prefix reversed state
  */
- Node flip(int flipPosition, int distance) {
+ Node flip(int flipPosition, int gap) {
 
- int[] flipped = new int[size];
+ int[] flipped = new int[state.length];
 
  for (int i = 0; i < flipPosition; i++) {
  flipped[i] = state[flipPosition - i - 1];
  }
 
- System.arraycopy(state, flipPosition, flipped, flipPosition, size - flipPosition);
+ System.arraycopy(state, flipPosition, flipped, flipPosition, state.length - flipPosition);
 
- return new Node(flipped, getDepth() + 1, distance);
+ return new Node(flipped, getDepth() + 1, gap);
  }
 
+ /**
+ * Augments the state of this node. An additional item is added at the end of the state.
+ *
+ * @return new instanced node with augmented state
+ */
  public Node augment() {
- int[] augmentedState = new int[size + 1];
- System.arraycopy(state, 0, augmentedState, 0, size);
- augmentedState[size] = size + 1;
+ int[] augmentedState = new int[state.length + 1];
+ System.arraycopy(state, 0, augmentedState, 0, state.length);
+ augmentedState[state.length] = state.length + 1;
  return new Node(augmentedState, getDepth());
  }
 
@@ -104,12 +116,11 @@ public int[] getState() {
  return state;
  }
 
- public int getDistance() {
- return distance;
- }
-
  public Stack<Node> getChildren() {
  return children;
  }
 
+ public int getGap() {
+ return gap;
+ }
 }

src/main/java/ch/sebastianhaeni/pancake/processor/Controller.java

@@ -72,7 +72,7 @@ private boolean solve() {
 
  initialWork();
 
- if (stack.peek().gap() == 0) {
+ if (stack.peek().getGap() == 0) {
  return true;
  }
 
@@ -138,15 +138,15 @@ private void clearListeners() {
 
  private void initialWork() {
  if (bound < 0) {
- bound = stack.peek().getDistance();
+ bound = stack.peek().getGap();
  }
  candidateBound = Integer.MAX_VALUE;
 
  int i = 0;
- while (stack.peek().gap() > 0 && i < INITIAL_WORK_DEPTH) {
+ while (stack.peek().getGap() > 0 && i < INITIAL_WORK_DEPTH) {
  i++;
- if (stack.peek().getDistance() + stack.peek().getDepth() > bound) {
-  int stateBound = stack.peek().getDepth() + stack.peek().getDistance();
+ int stateBound = stack.peek().getGap() + stack.peek().getDepth();
+ if (stateBound > bound) {
  if (stateBound < candidateBound) {
  candidateBound = stateBound;
  }

src/main/java/ch/sebastianhaeni/pancake/processor/Worker.java

@@ -38,7 +38,7 @@ public void run() {
 
  waitForWork();
 
- while (!stack.isEmpty() && stack.peek().gap() > 0 && !status.isDone()) {
+ while (!stack.isEmpty() && stack.peek().getGap() > 0 && !status.isDone()) {
  solve();
  }
 
@@ -61,9 +61,9 @@ private void listenToKill() {
  private void solve() {
  candidateBound = Integer.MAX_VALUE;
 
- while (!stack.isEmpty() && stack.peek().gap() > 0 && !status.isDone()) {
- if (stack.peek().getDistance() + stack.peek().getDepth() > bound) {
-  int stateBound = stack.peek().getDepth() + stack.peek().getDistance();
+ while (!stack.isEmpty() && stack.peek().getGap() > 0 && !status.isDone()) {
+ int stateBound = stack.peek().getGap() + stack.peek().getDepth();
+ if (stateBound > bound) {
  if (stateBound < candidateBound) {
  candidateBound = stateBound;
  }

src/main/java/ch/sebastianhaeni/pancake/util/Output.java

@@ -38,6 +38,9 @@ public static void showSolution(Vector<Node> nodes) {
  }
  }
 
+// sb.append(", gap: ");
+// sb.append(nodes.get(i).getGap());
+
  System.out.format("state %d: %s\n", i, sb.toString());
  }
  }

src/main/java/ch/sebastianhaeni/pancake/util/Partition.java

@@ -17,7 +17,7 @@ public Stack<Node> get(int index) {
  Stack<Node> nodes = new Stack<>();
 
  for (Node node : stack) {
- Node element = new Node(node.getState(), node.getDepth(), node.getDistance());
+ Node element = new Node(node.getState(), node.getDepth(), node.getGap());
  nodes.push(element);
 
  for (int i = node.getChildren().size() - 1 - index; i >= 0; i -= partitionCount) {