[LeetCode] Longest Increasing Subsequence

A typical O(n^2) solution uses dynamic programming. Let's use lens[j] to denote the length of the LIS ending with nums[j]. The state equations are

lens[0] = 1

lens[j] = max_{i = 0, 1, 2, ..., j - 1}(lens[j], lens[i] + 1)

Then the length of the LIS of nums is just the maximum value in lens. The code is as follows.

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if (nums.empty()) return 0;
        int n = nums.size(), ml = 1;
        vector<int> lens(n, 1);
        for (int j = 1; j < n; j++) {
            for (int i = 0; i < j; i++)
                if (nums[j] > nums[i])
                    lens[j] = max(lens[j], lens[i] + 1);
            ml = max(ml, lens[j]);
        }
        return ml;
    }
};

The O(nlogn) solution is much more complicated. Try to read through the explanation of it in GeeksforGeeks first. The code is as follows.

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if (nums.empty()) return 0;
        vector<int> ends{nums[0]};
        for (int num : nums) {
            if (num < ends[0]) ends[0] = num;
            else if (num > ends.back()) ends.push_back(num);
            else {
                int l = 0, r = ends.size() - 1;
                while (l < r) {
                    int m = l + (r - l) / 2;
                    if (ends[m] < num) l = m + 1;
                    else r = m;
                }
                ends[r] = num;
            }
        }
        return ends.size();
    }
};

If you look at the else part carefully, you may notice that it can be done using lower_bound. So we will have a much shorter code, like this one.

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> ends;
        for (int num : nums) {
            auto it = lower_bound(ends.begin(), ends.end(), num);
            if (it == ends.end()) ends.push_back(num);
            else *it = num;
        }
        return ends.size();
    }
};