Reimplemented ReinsertionDistance to use O(n lg n) alg for longest common subsequence

cicirello · cicirello · commit 9217c51b9d05 · 2018-08-17T11:03:14.000-04:00
diff --git a/docs/api/org/cicirello/permutations/distance/ReinsertionDistance.html b/docs/api/org/cicirello/permutations/distance/ReinsertionDistance.html
@@ -2,9 +2,9 @@
 <!-- NewPage -->
 <html lang="en">
 <head>
-<!-- Generated by javadoc (1.8.0_05) on Wed Aug 08 13:08:41 EDT 2018 -->
+<!-- Generated by javadoc (1.8.0_05) on Fri Aug 17 10:57:33 EDT 2018 -->
 <title>ReinsertionDistance (JavaPermutationTools - A Java API for computation on permutations)</title>
-<meta name="date" content="2018-08-08">
+<meta name="date" content="2018-08-17">
 <link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
 <script type="text/javascript" src="../../../../script.js"></script>
 </head>
@@ -127,19 +127,31 @@ <h2 title="Class ReinsertionDistance" class="title">Class ReinsertionDistance</h
  <p>This implementation utilizes the observation that the elements that must be removed and reinserted
  are exactly those elements that are not in the longest common subsequence.</p>
 
- <p>Runtime: O(n^2), where n is the permutation length.</p>
+ <p>Runtime: O(n lg n), where n is the permutation length.</p>
 
  <p>Reinsertion distance more generally was described in:<br>
  V. A. Cicirello and R. Cernera, <a href="https://www.cicirello.org/publications/cicirello2013flairs.html" target=_top>"Profiling the distance characteristics 
  of mutation operators for permutation-based genetic algorithms,"</a> 
  in Proceedings of the 26th FLAIRS Conference. AAAI Press, May 2013, pp. 46–51.</p> 
 
- <p>However, in that paper, it was computed using an adaptation of string Edit Distance.</p>
+ <p>However, in that paper, it was computed, in O(n^2) time, using an adaptation of string Edit Distance.</p>
 
  <p>For description of computing it using the length of the longest common subsequence, see:<br> 
  V.A. Cicirello, <a href="https://www.cicirello.org/publications/cicirello2016evc.html" target=_top>"The Permutation in a Haystack Problem 
  and the Calculus of Search Landscapes,"</a> 
- IEEE Transactions on Evolutionary Computation, 20(3):434-446, June 2016.</p></div>
+ IEEE Transactions on Evolutionary Computation, 20(3):434-446, June 2016.</p>
+
+ <p>However, that paper used an O(n^2) time algorithm for longest common subsequence.  This class has been
+ updated to use a more efficient O(n lg n) algorithm for longest common subsequence.  It is a version of
+ Hunt et al's algorithm 
+ that has been optimized to assume permutations of the integers in [0, (n-1)] with unique elements.
+ The original algorithm of Hunt et al was for general strings that could contain duplicates and which could consist 
+ of characters of any alphabet.  In that more general case, O(n lg n) was the best case runtime.  In our
+ special case, O(n lg n) is worst case runtime.</p>
+
+ <p>See the following for complete details of Hunt et al's algorithm for longest common subsequence:<br>
+ J.W. Hunt and T.G. Szymanski, "A fast algorithm for computing longest common subsequences," 
+ Communications of the ACM, 20(5):350-353, May, 1977.</p></div>
 <dl>
 <dt><span class="simpleTagLabel">Since:</span></dt>
 <dd>1.0</dd>
diff --git a/lib/jpt1.jar b/lib/jpt1.jar
diff --git a/src/org/cicirello/permutations/distance/ReinsertionDistance.java b/src/org/cicirello/permutations/distance/ReinsertionDistance.java
@@ -30,22 +30,34 @@
  * <p>This implementation utilizes the observation that the elements that must be removed and reinserted
  * are exactly those elements that are not in the longest common subsequence.</p>
  *
- * <p>Runtime: O(n^2), where n is the permutation length.</p>
+ * <p>Runtime: O(n lg n), where n is the permutation length.</p>
  *
  * <p>Reinsertion distance more generally was described in:<br>
  * V. A. Cicirello and R. Cernera, <a href="https://www.cicirello.org/publications/cicirello2013flairs.html" target=_top>"Profiling the distance characteristics 
  * of mutation operators for permutation-based genetic algorithms,"</a> 
  * in Proceedings of the 26th FLAIRS Conference. AAAI Press, May 2013, pp. 46–51.</p> 
  *
- * <p>However, in that paper, it was computed using an adaptation of string Edit Distance.</p>
+ * <p>However, in that paper, it was computed, in O(n^2) time, using an adaptation of string Edit Distance.</p>
  *
  * <p>For description of computing it using the length of the longest common subsequence, see:<br> 
  * V.A. Cicirello, <a href="https://www.cicirello.org/publications/cicirello2016evc.html" target=_top>"The Permutation in a Haystack Problem 
  * and the Calculus of Search Landscapes,"</a> 
  * IEEE Transactions on Evolutionary Computation, 20(3):434-446, June 2016.</p>
  *
+ * <p>However, that paper used an O(n^2) time algorithm for longest common subsequence.  This class has been
+ * updated to use a more efficient O(n lg n) algorithm for longest common subsequence.  It is a version of
+ * Hunt et al's algorithm 
+ * that has been optimized to assume permutations of the integers in [0, (n-1)] with unique elements.
+ * The original algorithm of Hunt et al was for general strings that could contain duplicates and which could consist 
+ * of characters of any alphabet.  In that more general case, O(n lg n) was the best case runtime.  In our
+ * special case, O(n lg n) is worst case runtime.</p>
+ *
+ * <p>See the following for complete details of Hunt et al's algorithm for longest common subsequence:<br>
+ * J.W. Hunt and T.G. Szymanski, "A fast algorithm for computing longest common subsequences," 
+ * Communications of the ACM, 20(5):350-353, May, 1977.</p>
+ *
  * @author <a href=https://www.cicirello.org/ target=_top>Vincent A. Cicirello</a>, <a href=https://www.cicirello.org/ target=_top>https://www.cicirello.org/</a>
- * @version 2.18.8.2 
+ * @version 2.18.8.17 
  * @since 1.0
  *
  */
@@ -61,7 +73,43 @@ public int distance(Permutation p1, Permutation p2) {
 		return p1.length() - lcs(p1,p2);
 	}
 	
+	// This version runs in O(n lg n)
 	private int lcs(Permutation p1, Permutation p2) {
+		int n = p1.length();
+		int[] inv = p2.getInverse();
+		int[] match = new int[n];
+		int[] thresh = new int[n+1];
+		thresh[0] = -1;
+		for (int i = 0; i < n; i++) {
+			match[i] = inv[p1.get(i)];
+			thresh[i+1] = n;
+		}
+		int maxK = 0;
+		for (int i = 0; i < n; i++) {
+			int j = match[i];
+			int k = binSearch(thresh, j, 0, maxK+1);
+			if (j < thresh[k]) {
+				thresh[k] = j;
+				if (k > maxK) maxK = k;
+			}
+		}
+		return maxK;
+	}
+	
+	private int binSearch(int[] array, int value, int low, int high) {
+		if (high == low) return low;
+		int mid = (high+low) / 2;
+		if (value <= array[mid] && value > array[mid-1]) {
+			return mid;
+		} else if (value > array[mid]) {
+			return binSearch(array, value, mid+1, high);
+		} else {
+			return binSearch(array, value, low, mid-1);
+		}
+	}
+	
+	// OLD O(n^2) Version: Keep temporarily
+	private int lcsOLD(Permutation p1, Permutation p2) {
 		int L1 = p1.length();
 		int L2 = p2.length();
 		int start = L1;
diff --git a/tests/org/cicirello/permutations/distance/PermutationDistanceTests.java b/tests/org/cicirello/permutations/distance/PermutationDistanceTests.java
@@ -268,6 +268,14 @@ public void testReinsertionDistance() {
 		assertEquals("all but 2 on longest common subsequence", 2, d.distance(p1,p2));
 		assertEquals("all but 3 on longest common subsequence", 3, d.distance(p1,p3));
 		assertEquals("all but 3 on longest common subsequence", 3, d.distance(p1,p4));
+		
+		Permutation p = new Permutation(6);
+		EditDistance edit = new EditDistance();
+		for (Permutation q : p) {
+			// NOTE: If this assertion fails, problem is either in ReinsertionDistance or EditDistance
+			// Should correspond if they are both correct.
+			assertEquals("equiv of edit with 0.5 cost removes and inserts", edit.distancef(p,q), d.distancef(p,q), EPSILON);
+		}
 	}
 	
 	@Test
