最长递增子序列（动态规划）

首先可以看看这个链接，讲解的还可以，不多通不过，因为有问题，可以先找它的问题，再看下面的代码

public int[] LIS (int[] arr) {
        // write code here
        int dp[] = new int[arr.length];
        int temp[] = new int[arr.length];
        dp[0] = 1;
        int tempIndex = 0;
        temp[tempIndex] = arr[0];
        for(int i = 1; i < arr.length; i++){
            int left = 0;
            int right = tempIndex;
            if(arr[i] > temp[tempIndex]){
                tempIndex++;
                dp[i] = tempIndex + 1;
                temp[tempIndex] = arr[i];
            }else{
                while(left <= right){
                    int mid = (left + right) >> 1;
                    if(temp[mid] > arr[i]){
                        right = mid - 1;
                    }else if(temp[mid] < arr[i]){
                        left = mid + 1;
                    }else{
                        left = mid;
                        break;
                    }
                }
                temp[left] = arr[i];
                dp[i] = left + 1;
            }
        }

        int res[] = new int[tempIndex + 1];
        for(int i = dp.length - 1; i>=0; i--){
            if(dp[i] == tempIndex + 1){
                res[tempIndex] = arr[i];
                --tempIndex;
            }
        }

        return res;
}

2021-12-22
下面是更优秀的解法：

class Solution {
    public int lengthOfLIS(int[] nums) {
        int length = nums.length;
        if(length == 0){
            return 0;
        }
        int[] d = new int[length + 1]; // 用一个递增的数组来维护一份差值最小的递增数组
        int len = 0;
        d[len] = nums[0];
        for(int i = 1; i < length; i++){
            if(nums[i] > d[len]){
                d[++len] = nums[i];
            }else{
                int l = 0, r = len, pos = 0;
                while(l <= r){
                    int mid = (l + r) >> 1;
                    if(d[mid] < nums[i]){//找到第一个比当前数小的数
                        pos = mid + 1;
                        l = mid + 1;
                    }else{
                        r = mid - 1;
                    }
                }
                d[pos] = nums[i];
            }
        }
        return len + 1;
    }
}