最长递增子序列

求一个一维数组中的最长递增子序列的长度

比如，在序列{1, -1, 2, -3, 4, -5, 6, -7}中，其最长的递增子序列为1,2,4,6

思路: 编程之美上的题，也是蛮经典的动态规划题。 思路还是去找规律，我们拿LCS来表示最长递增子序列的长度

第一个数1， 则LCS(1)=1, 因为就一个数嘛

第二个数-1,  LCS(1,-1)=1, 因为-1对于1来说不是递增的

第三个数2, LCS(1,-1,2)=2, 因为2对于前两个数是递增的

所以规律是 LCS(i) =   if a[i] > a[0...i-1]  => max(1, LCS(1...i-1)) + 1 就是如果a[i]的值大于数组下标在0到i-1之间的全部数, 且max(1, LCS(1...i-1))+1>LCS(i)

void findLCS01(int[] array){
        int len = array.length;
        int[] LIS = new int[len];
        
        for(int i = 0; i < len; i++){
            LIS[i] = 1;
            for(int j = 0; j<i; j++){
                if(array[i] > array[j] && LIS[j] + 1 > LIS[i]){
                    LIS[i] = LIS[j] + 1;
                }
            }
        }
        
        show(LIS);
    }

上述的方法需要嵌套内循环，当遍历到a[i]元素时，需要对0到i-1之间的元素，依次判断是否小于当前a[i]元素，并且找出最大的LCS值，将其加一付给LCS[i], 时间复杂度是o(n^2)

为了降低时间复杂度，编程之美上的解决方法是对i之前的元素进行快速排序，这样就不用每次都去遍历他们，我的想法是，可以增加一个数组max，max[i-1]保存的是从0到i-1之间遇到的最大元素，数组LCS, LCS[i]保存0到i之间的最大值, 这样每次只需比较a[i]与max[i-1]即可, 如果a[i]>max[i-1] 则max[i]=a[i]然后再去判断LCS的值，否则LCS[i]沿用LCS[i-1], max[i]沿用max[i-1]

void findLCS02(int[] array){
        int len = array.length;
        
        if(len <= 0) return;
        if(len <= 1) return;
        
        int[] LCS = new int[len];
        int[] max = new int[len];
        
        LCS[0] = 1;
        max[0] = array[0];
        
        for(int i = 1; i < len; i++){
            LCS[i] = 1;
            if(array[i] > max[i-1]){
                max[i] = array[i];
                if(LCS[i-1] + 1 > LCS[i]){
                    LCS[i] = LCS[i-1] + 1;
                }
            }else{
                LCS[i] = LCS[i-1];
　　　　　　　　　　　max[i] = max[i-1];
            }
        }
        
        show(LCS);
    }

 这样时间复杂度将为o(n), 用空间换时间了