Longest Increasing Sequence

 public class Longest_Increasing_Subsequence {
     /**
      * O(N^2)
      * DP
      * 思路：
      *  示例：[1,0,2,4,10,5]
      *  找出以上数组的LIS的长度
      * 分析:
      *  只要求长度，并不要求找出具体的序列
      * 问题可以拆分为
      *      1. 对于[1]，找出LIS
      *      2. 对于[1,0]，找出LIS
      *      3. 对于[1,0,2]，找出LIS
      *      4. 对于[1,0,2,4]，找出LIS
      *      ...
      *      最后，对于[1,0,2,4,10,5],找出LIS
      * 再进一步思考，例如：
      *  找出[-1,0,1,0,2,4]的LIS，就要找到在4之前符合条件（都比4小且都为升序）的LIS的长度 => [-1,0,1]是满足情况的(最长，都是升序，都比4小)
      *  那么就要有一个数据结构来记录到某一个index上，LIS的长度。因为每一个index上的LIS长度并不是固定为前一个加1，所以每一个都要记录下来 => 数组dp[]
      *  dp[i]记录的是，在i这个index上，LIS的长度
      *  比如：
      * index 0 1 2 3 4 5
      *  dp:[ 1,2,3,1,4,5] //dp数组
      *  ar:[-1,0,1,0,2,4] //原数组
      *  dp[1] = 2表示在1这个index上，LIS的长度是2（[-1,0]）
      *  dp[4] = 4表示在4这个index上，LIS的长度是4（[-1,0,1,2]）
      * ----------------------------
      * 状态转换方程：
      * dp[i] = dp[k] + 1; (dp[k] = max(dp[0], dp[1], ... dp[i-1]))  // dp[i] = 在i以前最大的LIS长度加上1
      * 以上方程的成立条件：
      *      nums[k] < nums[i] //保持递增序列的属性
      */

     /**
      * O(N^2)
      */
     public int lengthOfLIS(int[] nums) {
         int[] dp = new int[nums.length];
         dp[0] = 1;
         for (int i = 1; i < nums.length; i++) {
             int beforeMaxLen = dp[i];
             // 在0 ~ i之间比较LIS的长度
             for(int j = 0; j < i; j++) {
                 if (nums[j] < nums[i] && dp[j] > beforeMaxLen) { //注意dp[j] > beforeMaxLen，新的长度要大于之前选出来的长度才能更新
                     beforeMaxLen = dp[j];
                 }
             }
             dp[i] = beforeMaxLen + 1;
         }
         int max = 0;
         // 在数组里找出最大的长度即可
         for (int i = 0; i < nums.length; i++) {
             if (dp[i] > max){
                 max = dp[i];
             }
         }
         return max;
     }

     /**
      * O(N*logN)
      * 思路：
      *  满足递增序列，就直接加入list中
      *  如果发现有降序出现，找出在原数组中比它大的第一个数的index，然后在list中替换那个数
      *  最后返回list的长度
      * 原理：
      *  因为只求长度，所以没有必要存储确切的sequence
      */
     public int lengthOfLIS_2(int[] nums) {
         List<Integer> list = new ArrayList<>();
         for(int num : nums) {
             if(list.isEmpty() || list.get(list.size() - 1) < num) { // 不满足递增序列
                 list.add(num);
             } else {
                 list.set(findFirstLargeEqual(list, num), num);
             }
         }

         return list.size();
     }

     private int findFirstLargeEqual(List<Integer> list, int target)
     {
         int start = 0;
         int end = list.size() - 1;
         while(start < end) {
             int mid = start + (end - start) / 2;
             if(list.get(mid) < target) {
                 start = mid + 1;
             }
             else {
                 end = mid;
             }
         }

         return end;
     }

     /**
      * 测试用
      */
     public static void main(String[] args) {
         Longest_Increasing_Subsequence lis = new Longest_Increasing_Subsequence();
         int[] a = {-1,0,1,0,2,4};
         System.out.print(lis.lengthOfLIS_2(a));
     }
 }