最长递增子序列（LIS）不连续

很牛的一个方法，实现也牛逼
‘’’
给的实例
[10, 11, 12, 13, 1, 2, 3, 4, 5]
跟单调栈还有一点不同
[10, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 11, 0, 0, 0, 0, 0, 0, 0]
[10, 11, 12, 0, 0, 0, 0, 0, 0]
[10, 11, 12, 13, 0, 0, 0, 0, 0]
# 单调栈是要全出来，而这里不是
[1, 11, 12, 13, 0, 0, 0, 0, 0]
[1, 2, 12, 13, 0, 0, 0, 0, 0]
[1, 2, 3, 13, 0, 0, 0, 0, 0]
[1, 2, 3, 4, 0, 0, 0, 0, 0]
[1, 2, 3, 4, 5, 0, 0, 0, 0]
‘’’

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        # 二分查找实现单调栈,这个虽然叫做单调栈，但是跟他的实现不一样，虽然结果都是单调的，让内层循环从n到logn
        tails = [0] * len(nums)
        size = 0
        for x in nums:
            # 二分查找（0到size一直是升序的）
            # 实现的功能是从0到size找到第一个大于等于x的元素，用x替换此元素，若果找不到放到最后，增加size长度
            i, j = 0, size
            # 不要i <= j
            while i != j:
                m = i + (j - i) // 2
                if tails[m] < x:
                    i = m + 1
                else:
                    # 不要 m - 1
                    j = m
            tails[i] = x
            size = max(i + 1, size)
            # print(tails)
        return size

/*
public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
用法：参考博客https://blog.csdn.net/cxhply/article/details/49423501
插入点是索引键将要插入数组的那一点，即第一个大于该键的元素的索引。
*/
public class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        // 定义 排好序的递增数组的长度
        int len = 0;
        for (int num : nums) {
            // 返回 0 到 len 之间的指定值，双闭区间
            int i = Arrays.binarySearch(dp, 0, len, num);
            // 没找到 转换成第一个大于该键的索引， 如果都小于要找的值， 那么转换成的索引变成len + 1
            if (i < 0) {
                i = -(i + 1);
            }
            // 有值比它大，是替换比他大的第一个值，没有就增加到末尾，这一部分是二分查找排好序的数组（0-len）的插入点
            // 时间复杂度log(len)
            dp[i] = num;
            if (i == len) {
                len++;
            }
        }
        return len;
    }
}