implemented recursive best pancake flip order solver

Author: sebastianhaeni

number-generator.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var amountOfNumbers = 20;
+
+var n = [];
+for (var i = 0; i < amountOfNumbers; i++) {
+ n[i] = i + 1;
+}
+
+shuffle(n);
+console.log(n.toString());
+
+function shuffle(a) {
+ var j, x, i;
+ for (i = a.length; i; i--) {
+ j = Math.floor(Math.random() * i);
+ x = a[i - 1];
+ a[i - 1] = a[j];
+ a[j] = x;
+ }
+}

pom.xml

@@ -7,6 +7,14 @@
 <groupId>parallel-computing-mpj</groupId>
 <artifactId>parallel-computing-mpj</artifactId>
 <version>1.0-SNAPSHOT</version>
+ <dependencies>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>4.8.1</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
 
 
 </project>

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

@@ -0,0 +1,83 @@
+package ch.sebastianhaeni.pancake;
+
+import java.util.List;
+
+public class Main {
+
+ public static void main(String[] args) {
+
+// Node root = new Node(new int[]{46, 53, 18, 4, 56, 11, 57, 59, 55, 25, 6, 34, 41, 13, 39, 52, 7, 33, 43, 21, 32, 51, 5, 1, 58, 49, 54, 9, 24, 17, 19, 27, 50, 42, 22, 30, 20, 3, 14, 28, 40, 10, 12, 29, 37, 8, 36, 2, 26, 38, 16, 60, 15, 48, 35, 45, 31, 44, 23, 47}, 0);
+// Node root = new Node(new int[]{2, 6, 10, 5, 1, 3, 8, 4, 7, 9}, 0);
+// Node root = new Node(new int[]{1, 2, 3}, 0);
+// Node root = new Node(new int[]{11, 7, 15, 6, 17, 3, 19, 16, 4, 10, 8, 12, 20, 14, 2, 5, 1, 9, 13, 18}, 0);
+ Node root = new Node(new int[]{5, 2, 7, 10, 13, 16, 14, 6, 8, 15, 11, 1, 12, 3, 4, 9}, 0);
+
+ long start = System.currentTimeMillis();
+ Node solution = solve(root);
+ long end = System.currentTimeMillis();
+
+ System.out.println((end - start) + "ms passed");
+
+ if (solution == null) {
+ System.out.println("No solution found");
+ return;
+ }
+ System.out.println("Found solution after " + solution.getFlipCount() + " flips.");
+ }
+
+ private static Node solve(Node root) {
+ if (root.isSolution()) {
+ return root;
+ }
+
+ Node solutionNode = null;
+ int bound = root.getOptimisticDistanceToSolution();
+ int maxBound = bound * 10;
+
+ while (solutionNode == null) {
+ SearchResult result = search(root, bound);
+
+ if (result.solutionNode != null) {
+ solutionNode = result.solutionNode;
+ }
+
+ if (result.bound >= maxBound) {
+ return null;
+ }
+
+ bound = result.bound;
+ }
+
+ return solutionNode;
+ }
+
+ private static SearchResult search(Node node, int bound) {
+ int newBound = node.getFlipCount() + node.getOptimisticDistanceToSolution();
+
+ if (newBound > bound) {
+ return new SearchResult(newBound);
+ }
+
+ if (node.isSolution()) {
+ return new SearchResult(node);
+ }
+
+ int min = Integer.MAX_VALUE;
+ List<Node> successors = node.nextNodes();
+
+ for (Node successor : successors) {
+ SearchResult result = search(successor, bound);
+
+ if (result.solutionNode != null) {
+ return result;
+ }
+
+ if (result.bound < min) {
+ min = result.bound;
+ }
+ }
+
+ return new SearchResult(min);
+ }
+
+}

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

@@ -0,0 +1,81 @@
+package ch.sebastianhaeni.pancake;
+
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.List;
+
+class Node {
+ private final int[] pancakes;
+ private final int flipCount;
+
+ Node(int[] pancakes, int flipCount) {
+ this.pancakes = pancakes;
+ this.flipCount = flipCount;
+ }
+
+ int getOptimisticDistanceToSolution() {
+ int distance = 0;
+ int current = 1;
+
+ for (int i = 1; i < pancakes.length; i++) {
+ int pancake = pancakes[i];
+ if (Math.abs(pancake - current) != 1) {
+ distance++;
+ }
+ current = pancake;
+ }
+
+ return distance;
+ }
+
+ int getFlipCount() {
+ return flipCount;
+ }
+
+ boolean isSolution() {
+ int current = 1;
+
+ for (int i = 1; i < pancakes.length; i++) {
+ int pancake = pancakes[i];
+ if (pancake - current != 1) {
+ return false;
+ }
+ current = pancake;
+ }
+
+ return true;
+ }
+
+ List<Node> nextNodes() {
+ AbstractList<Node> list = new ArrayList<>();
+
+ int current = pancakes[1];
+
+ for (int i = 1; i < pancakes.length; i++) {
+ int pancake = pancakes[i];
+ if (pancake - current != 1) {
+ list.add(flip(i + 1));
+ }
+ current = pancake;
+ }
+
+ return list;
+ }
+
+ Node flip(int flipPosition) {
+
+ int[] flipped = new int[pancakes.length];
+
+ for (int i = 0; i < flipPosition; i++) {
+ flipped[i] = pancakes[flipPosition - i - 1];
+ }
+
+ System.arraycopy(pancakes, flipPosition, flipped, flipPosition, pancakes.length - flipPosition);
+
+ return new Node(flipped, getFlipCount() + 1);
+ }
+
+ int[] getPancakes() {
+ return pancakes;
+ }
+}

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

@@ -0,0 +1,14 @@
+package ch.sebastianhaeni.pancake;
+
+class SearchResult {
+ Node solutionNode;
+ int bound;
+
+ SearchResult(Node node) {
+ this.solutionNode = node;
+ }
+
+ SearchResult(int bound) {
+ this.bound = bound;
+ }
+}

src/main/java/idaStar/Main.java

@@ -0,0 +1,54 @@
+package ch.sebastianhaeni.pancake;
+
+import org.junit.Test;
+
+import java.util.List;
+
+import static junit.framework.Assert.assertEquals;
+import static org.junit.Assert.*;
+
+public class NodeTest {
+
+ @Test
+ public void testFlip1() {
+ Node node = new Node(new int[]{1, 2}, 0);
+ Node flip = node.flip(1);
+ assertArrayEquals(new int[]{1, 2}, flip.getPancakes());
+ }
+
+ @Test
+ public void testFlip2() {
+ Node node = new Node(new int[]{1, 2, 3}, 0);
+ Node flip = node.flip(2);
+ assertArrayEquals(new int[]{2, 1, 3}, flip.getPancakes());
+ }
+
+ @Test
+ public void testFlip3() {
+ Node node = new Node(new int[]{2, 6, 10, 5, 1, 3, 8, 4, 7, 9}, 0);
+ Node flip = node.flip(5);
+ assertArrayEquals(new int[]{1, 5, 10, 6, 2, 3, 8, 4, 7, 9}, flip.getPancakes());
+ }
+
+ @Test
+ public void testIsSolution1() {
+ Node node = new Node(new int[]{1, 2, 3}, 0);
+ assertTrue(node.isSolution());
+ }
+
+ @Test
+ public void testIsSolution2() {
+ Node node = new Node(new int[]{2, 1, 3}, 0);
+ assertFalse(node.isSolution());
+ }
+
+ @Test
+ public void testNextNodes() {
+ Node node = new Node(new int[]{2, 1, 3}, 0);
+ List<Node> nodes = node.nextNodes();
+
+ assertEquals(2, nodes.size());
+ assertArrayEquals(nodes.get(0).getPancakes(), new int[]{1, 2, 3});
+ assertArrayEquals(nodes.get(1).getPancakes(), new int[]{3, 1, 2});
+ }
+}