Description:

Given a sequence of integers, find the longest increasing subsequence (LIS).

You code should return the length of the LIS.

Example:

For [5, 4, 1, 2, 3], the LIS is [1, 2, 3], return 3
For [4, 2, 4, 5, 3, 7], the LIS is [2, 4, 5, 7], return 4

Link:

http://www.lintcode.com/en/problem/longest-increasing-subsequence/

题目意思：

给一个数组nums，找出这个数组中最长的递增子集的个数，子集元素在数组中的顺序不能打破。

解题方法：

DP:

1. 创建一个数组dp，代表数组中每个元素前面有几个比它小的元素（递增），从到到尾遍历数组nums，在i位置时，j从i-1到0去查找比nums[i]小的元素，在这些元素中找到对应的dp值最大的。状态方程为：dp[i] = max(dp[j])+1。
   最后在dp中找到最大值max，并返回max+1。
2. 维护一个递增的数组dp，利用binary search来查找输入数组中每个数在这个数组中的位置，并且在每次查找后，将查找的数替换dp中相应位置原有的数（如果查找的index超过dp的长度则在最后则添加在后面）。

Tips:

注意dp数组仅仅记录了在某个位置上的元素前面有几个符合题目标准的数字，所以最后返回结果要+1，这才代表子集的个数。

Time Complexity：

时间O(N^2) 空间O(N)

时间O(NlogN) 空间O(N)

完整代码：

1.
int longestIncreasingSubsequence(vector<int> nums) 
    {
        if(nums.size() == 0)
            return 0;
        vector <int> dp (nums.size(), 0);
        for(int i = 1; i < nums.size(); i++)
        {
            int max = 0; 
            bool find = false;
            for(int j = i-1; j >= 0; j--)
            {
                if(nums[j] < nums[i])
                {
                    max = dp[j] > max ? dp[j] : max;
                    find = true;
                }
            }
            if(find)
                dp[i] = max+1; //如果没找到，dp值依然为0
        }
        int max = 0;
        for(int i = 1; i < dp.size(); i++)
            max = dp[i] > max ? dp[i] : max;
        return max+1;
    }
2.
int bs(vector<int>& nums, int n) {
    int len = nums.size();
    if(!len || n < nums[0])
        return 0;
    if(n > nums[len - 1])
        return len;
    int start = 0, end = len - 1;
    while(start + 1 < end) {
        int mid = start + (end - start) / 2;
        if(nums[mid] == n)
            return mid;
        else if(nums[mid] > n)
            end = mid;
        else 
            start = mid;
    }
    if(nums[start] == n)
        return start;
    if(nums[end] == n)
        return end;
    if(nums[start] > n)
        return start;   
    else 
        return end;
}

int LIS(vector<int>& nums) {
    int len = nums.size();
    if(len < 2)
        return len;
    vector<int> DP;
    for(int i: nums) {
        int index = bs(DP, i);
        if(index == DP.size())
            DP.push_back(i);
        else 
            DP[index] = i;
    }
    return DP.size();
}