longestIncreasingSequence最长上升子序列问题

 package dp;

 /**
  * 最长上升子序列问题
  */
 public class LongestIncreasingSubsequence
 {
     /**
      * 原始dp
      * @param arr
      * @return
      */
     public static int maxLength(int[] arr)
     {
         int[] len = new int[arr.length] ; //以i为结尾的最长上升子序列
         int[] mark = new int[arr.length] ;//标记以i为结尾的最长上升子序列的上一个节点所在的上上子序列位置
         len[0] = 1 ;
         mark[0] = -1 ;

         int maxPos = 0 ;
         for(int i=1 ; i<len.length ; i++)
         {
             len[i] = 1 ;
             mark[i] = -1 ;
             for(int j=i-1 ; j>=0 ; j--)
             {
                 if(arr[j] < arr[i] && (len[j]+1) > len[i])
                 {
                     len[i] = len[j]+1 ;
                     mark[i] = j ;
                 }

             }
             if(len[maxPos] < len[i])
                 maxPos = i ;
         }

         int maxP = maxPos ;
         while (maxP != -1)
         {
             System.out.println(arr[maxP]);
             maxP = mark[maxP] ;
         }
         return len[maxPos] ;
     }

     /**
      * 使用二分加速的dp
      * @param arr
      * @return
      */
     public static int maxLength2(int[] arr)
     {
         int[] len = new int[arr.length] ; //以i为结尾的最长上升子序列
         int[] mark = new int[arr.length] ;//标记以i为结尾的最长上升子序列的上一个节点所在的上上子序列位置
         int[] m = new int[arr.length+1] ;//标记长度为x的子序列的最小值在arr中的位置

         int mLength = 1 ;
         len[0] = 1 ;
         mark[0] = -1 ;
         m[1] = 0 ;

         int maxPos = 0 ;
         for(int i=1 ; i<len.length ; i++)
         {
             len[i] = 1 ;
             mark[i] = -1 ;

             int pos = binarySearch(arr , m , mLength , arr[i]) ;

             if(pos != -1)
             {
                 len[i] = len[pos]+1 ;
                 mark[i] = pos ;
             }

             if(mLength < len[i])
             {
                 m[len[i]] = i ;
                 mLength++ ;
             }
             else if(arr[m[len[i]]] > arr[i])
             {
                 m[len[i]] = i ;
             }

             if(len[maxPos] < len[i])
                 maxPos = i ;
         }

         int maxP = maxPos ;
         while (maxP != -1)
         {
             System.out.println(arr[maxP]);
             maxP = mark[maxP] ;
         }
         return len[maxPos] ;
     }

     /**
      * 寻找arr中比k小的最大数
      * @param n 表示m的长度
      * @param m 表示标记长度为x的子序列的最小值的位置的数组
      * @return 该元素在arr中的位置(为标记函数而服务的)
      */
     private static int binarySearch(int[] arr , int[] m , int n , int k) {
         int lo = 1;
         int hi = n;

         while ((hi-lo) > 1)
         {
             int mid = lo + (hi-lo)/2 ;

             if(arr[m[mid]] < k)
                 lo = mid ;
             else
                 hi = mid ;
         }

         if(arr[m[hi]] < k)
              return m[hi] ;
         else if(arr[m[lo]] < k)
             return m[lo] ;
         else
             return -1 ;
     }

     public static void main(String[] args) {
         int[] arr = new int[]{
         //        1,4,8,3,4,5
          //   3,5,1,7,5,9,3,5
                 1, 7, 3, 5, 9, 4, 1
         } ;

         System.out.println(maxLength2(arr));
     }
 }

//http://blog.csdn.net/code_pang/article/details/8757380

//http://blog.csdn.net/chenwenshi/article/details/6027086