LeetCode 300. Longest Increasing Subsequence

Given an unsorted array of integers, find the length of longest increasing subsequence.
题意：给你一个无序整数数组，找到最长递增子序列的长度。

For example,
Given [10, 9, 2, 5, 3, 7, 101, 18],
The longest increasing subsequence is [2, 3, 7, 101], therefore the length is 4. Note that there may be more than one LIS combination, it is only necessary for you to return the length.
例如：[10, 9, 2, 5, 3, 7, 101, 18]最长子序列为[2, 3, 7, 101]，长度为4。注意可能有不只一个最长递增子序列的组合，只需要返回长度。

Your algorithm should run in O(n^2) complexity.
你的算法运行时长应该在O(n^2)复杂度之内。

Follow up: Could you improve it to O(n log n) time complexity?
另外：你能否把时间复杂度优化到O(n log n)

Approach One： Dynamic Programming
Time Complexity ： O(n^2)

/*
我们使用dp[i]来表示i处的lengthOfLIS，初始化dp[] = {1}，那么我们要如何求dp[i]呢？
1.  dp[0] = 1
2.  dp[i] :
    for j in dp[0..i - 1]:
        if(nums[j] < nums[i])
            dp[i] = max(dp[j] + 1, dp[i])
        else continue

3. 求得了dp[0..n - 1]，我们从中取得最大dp[i]即可
*/
int lengthOfLIS(vector<int>& nums) {
    if(nums.empty()) return 0;

    int n = nums.size();
    int max_len = 1;
    vector<int> dp(n, 1);   // 最小长度为1
    for(int i = 1; i < n; ++i){     // 循环 [1, n)
        for(int j = 0; j < i; ++j){ // 查看 j in [0, i) 能否与 i 形成递增序列
            if(nums[j] < nums[i])   // j 与 i 可以组成递增序列
                dp[i] = max(dp[j] + 1, dp[i]);
            else
                continue;
        }
        max_len = max(dp[i], max_len);
    }

    return max_len;
}

Approach Two： Time Complexity O(n log n)
原文链接， 详细的解释

// Binary search (note boundaries in the caller)
int CeilIndex(std::vector<int> &nums, int l, int r, int key) {
    while (r-l > 1) {
    int m = l + (r-l)/2;
    if (nums[m] >= key)
        r = m;
    else
        l = m;
    }

    return r;
}

int lengthOfLIS(vector<int>& nums) {
    if (nums.size() == 0)
        return 0;

    std::vector<int> tail(nums.size(), 0);
    int length = 1; // always points empty slot in tail

    tail[0] = nums[0];
    for (size_t i = 1; i < nums.size(); i++) {
        if (nums[i] < tail[0])
            // new smallest value
            tail[0] = nums[i];
        else if (nums[i] > tail[length-1])
            // nums[i] extends largest subsequence
            tail[length++] = nums[i];
        else
            // nums[i] will become end candidate of an existing subsequence or
            // Throw away larger elements in all LIS, to make room for upcoming grater elements than nums[i]
            // (and also, nums[i] would have already appeared in one of LIS, identify the location and replace it)
            tail[CeilIndex(tail, -1, length-1, nums[i])] = nums[i];
    }

    return length;
}