算法导论15.4-6 求一个n个数的序列的最长单调递增子序列 O(n*logn)

算法导论 15.4-6 
 Give an O(nlgn) time algorithm to find the longest monotonically increasing subsequence of a sequence of n numbers.

 (Hint: Observe that the last element of a candidate subsequence of length i is at least as large as the last element of a candidate subsequence of length i-1. 

Maintain candidate subsequences by linking them through the input sequence.)

 子序列下标不要求是连续的。参考两篇文章：

http://blog.csdn.net/wdq347/article/details/8978394

http://blog.csdn.net/wangche320/article/details/9185919

下面是Java代码。

  /** 
   * The max increasing subsequence must be ended with one(or several) of the array,   
   * To find the max increasing subsequence, is to find all length subsequences ending with each array member,
   *  and choose the max length in them. 
   */  
  public static void findLongestIncreaseSubseq(int[] array, int n) { // O(nlgn)
    System.out.println(Arrays.toString(array));
    int[] preValues = new int[n]; // the previous element of max subsequence for current element
    int[] minEnding = new int[n]; // the increasing min ending value of all max subsequence
    int minDefValue = -1;  // or set to Integer.MIN_VALUE;
    for(int k=0; k<n; k++) {
      minEnding[k] = minDefValue;
      preValues[k] = minDefValue;
    }
    int maxLen = 1; // the length of max subsequence
    int maxIndex = 0; // the index of last element of max subsequence
    minEnding[0] = array[0];
    for(int i=1; i<n; i++) { // 依次寻找以 array[i]结尾的递增子序列
      //在所有子序列的最小结束元素数组中找到array[i]的插入位置
      int pos = findPosByBinarySearch(minEnding, 0, maxLen, array[i]);
      if( pos == maxLen ){
        minEnding[pos] = array[i];
        maxLen ++;
        maxIndex = i;
        // set the former when find longer subsequence ending with current element
        preValues[i]=minEnding[pos-1];
      }
      else {
        if(array[i] <= minEnding[pos]) { //if equal, the later still replace the former
          minEnding[pos] = array[i];
          // current element is smaller then previous subsequence
          preValues[i] = minDefValue;
        }
        else { // if(array[i] > minEnding[pos])
          // the former is minEnding[pos] for the subsequence ending with current element
          preValues[i] = minEnding[pos];
        }
      }
    }
    // maxLen is the length of using minEnding
    System.out.println("max len:"+maxLen);
    System.out.println("minEndings:\n" + Arrays.toString(minEnding));
    System.out.println("max index:"+maxIndex);
    System.out.println("preValues:\n" + Arrays.toString(preValues));

    Queue<Integer> maxSeqQueue = new ArrayDeque<Integer>();
    for(int index=0; index < preValues.length; index++) {
      if(preValues[index] != minDefValue) {
        maxSeqQueue.offer(preValues[index]);
      }
    }
    maxSeqQueue.offer(array[maxIndex]);
    System.out.println("max subsequence:\n"+maxSeqQueue);
  }
  /**
   * The minEnding is sorted array to store the min value of all length subsequences, 
   * the index=0 means the increasing subsequence length is 1. 
   */
  static int findPosByBinarySearch(int[] minEnding, int start, int length, int value) {
    int end = length -1;
    if(value > minEnding[end]) { //若value大于最大子序列最小值，返回length
      return length;
    }
    if(value < minEnding[start]) { // 若value小于最小子序列最小值，返回0
      return start;
    }
    // find the insert position for element by binary search O(lgn)
    while(start <= end) {
      int mid = (start+end) >>> 1; // 无符号右移
      if(minEnding[mid] == value) {
        return mid;
      }
      else if(minEnding[mid] < value) {
        start = mid +1;
      }
      else if(minEnding[mid] > value) {
        end = mid -1;
      }
    }
    return start; // return the start position if not find equal one
  }

  public static void main(String[] args) {
    int[] array = { 4, 2, 3, 7, 6, 12, 5 };
    findLongestIncreaseSubseq(array, array.length);
    int[] array1 ={0,1,3,5,1,4,6,7,0,8,9,2};
    findLongestIncreaseSubseq(array1, array1.length);
    int[] array2 ={2,1,3,0,4,1,5,2,7};
    findLongestIncreaseSubseq(array2, array2.length);
  }

  算法导论 15.4-5  求一个n个数的序列的最长单调递增子序列 子序列下标不要求是连续的
 Give an O(n^2) time algorithm to find the longest monotonically increasing
 subsequence of a sequence of n numbers.  

  // find longest increase subsequence with dynamic programming
  public static void getLongestIncreaseSubseq(int[] array, int n) { // O(n^2)
    System.out.println(Arrays.toString(array));
    int[] maxLengths = new int[n]; // the max length of current longest sequence
    int[] lastIndexs = new int[n]; // index of last element of longest sequence
    for(int k=0; k<n; k++) {
      maxLengths[k] = 1;  // at least length is 1, and previous set to -1
      lastIndexs[k] = -1;
    }
    int maxLen = 1;
    int maxIndex = 0;
    for (int i = 1; i < n; i++) {
      for (int j = 0; j < i; j++) {
        //循环比较当前元素和其之前所有元素
        if (array[i] > array[j]) { //若比前面的元素大，是一个单增子序列中的元素
          if (maxLengths[i] < maxLengths[j] + 1) { // 若当前子序列长度 < 前面元素的子序列长度+1
            maxLengths[i] = maxLengths[j] + 1;
            lastIndexs[i] = j; // 若是子序列中的元素，记录比第i个数小的第j个数的下标
          }
        }
      }
      if(maxLengths[i] > maxLen) {
        maxLen = maxLengths[i];
        maxIndex = i;
      }
    }
    System.out.println("longest subsequence length:" + maxLen);
    System.out.println("longest subsequence last index:" + maxIndex);
//    System.out.println(Arrays.toString(maxLengths));
//    System.out.println(Arrays.toString(lastIndexs));
    System.out.println("longest subsequence:");
    Deque<Integer> stack = new ArrayDeque<Integer>(); 
    int k=maxIndex;
    for(; maxLengths[k] > 1; ) {
      stack.push(array[k]);
      k = lastIndexs[k];
    }
    stack.push(array[k]);
    System.out.println(stack);
  }