Closes phishman3579#91 Bug fix

Author: phishman3579

src/com/jwetherell/algorithms/sequence/LongestIncreasingSubsequence.java

@@ -1,9 +1,5 @@
 package com.jwetherell.algorithms.sequence;
 
-import com.jwetherell.algorithms.search.LowerBound;
-
-import java.util.Arrays;
-
 /**
  * In computer science, the longest increasing subsequence problem is to find a subsequence of a given sequence in which the subsequence's elements are in sorted order, lowest to highest, and in 
  * which the subsequence is as long as possible. This subsequence is not necessarily contiguous, or unique. 
@@ -20,19 +16,43 @@ private LongestIncreasingSubsequence() { }
     /**
      * Longest increasing subsequence solved using dynamic programming. 
      */
-    public static int[] getLongestIncreasingSubsequence(int[] sequence) {
-        final int[] resultSequence = new int[sequence.length];
+    public static int[] getLongestIncreasingSubsequence(int[] X) {
+        final int[] P = new int[X.length];
+        final int[] M = new int[X.length+1];
+        int L = 0;
+        for (int i=0; i<X.length; i++) {
+            // Binary search for the largest positive j ≤ L such that X[M[j]] < X[i]
+            int lo = 1;
+            int hi = L;
+            while (lo <= hi) {
+                final int mid = (int) Math.ceil((lo + hi) / 2);
+                if (X[M[mid]] < X[i])
+                    lo = mid+1;
+                else
+                    hi = mid-1;
+            }
+
+            // After searching, lo is 1 greater than the length of the longest prefix of X[i]
+            final int newL = lo;
+
+            // The predecessor of X[i] is the last index of the subsequence of length newL-1
+            P[i] = M[newL-1];
+            M[newL] = i;
+            
+            if (newL > L) {
+                // If we found a subsequence longer than any we've found yet, update L
+                L = newL;
+            }
+        }
 
-        int resultLength = 0;
-        for (int i = 0; i < sequence.length; ++i) {
-            // try to find the best place for new element in sorted result
-            final int pos = LowerBound.lowerBound(resultSequence, resultLength, sequence[i]); //O(log n)
-            // if the best place is at the end increase result length
-            if (pos >= resultLength)
-                resultLength++;
-            resultSequence[pos] = sequence[i];
+        // Reconstruct the longest increasing subsequence
+        final int[] S = new int[L];
+        int k = M[L];
+        for (int i=L-1; i>=0; i--) {
+          S[i] = X[k];
+          k = P[k];
         }
 
-        return Arrays.copyOfRange(resultSequence, 0, resultLength);
+        return S;
     }
 }

test/com/jwetherell/algorithms/sequence/test/Sequences.java

@@ -141,7 +141,7 @@ public void testLongestIncreasingSubsequence() {
         sequencesLis.add(new int[]{1, 2, 3});
 
         sequences.add(new int[]{0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15});
-        sequencesLis.add(new int[]{0, 1, 3, 7, 11, 15});
+        sequencesLis.add(new int[]{0, 2, 6, 9, 11, 15});
 
         assertTrue("Longest increasing subsequence error. Sequences size=" + sequences.size() + " SequencesList size:" + sequencesLis.size(), sequences.size() == sequencesLis.size());