最长上升子序列

题目描述

给定一个无序的整数数组，找到其中最长上升子序列的长度。
示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4 
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

题解

int lengthOfLIS(vector<int>& nums)
{
    if(nums.size() == 0)//输入有可能为空
        return 0;
    vector<int> dp;

    dp.push_back(nums[0]);

    int ans = 1;
    for(unsigned int i = 1; i < nums.size(); i++)
    {
        int len = dp.size();
        if(nums[i] > dp[len-1])
            dp.push_back(nums[i]);
        else
        {
            for(int j = 0; j < len; j++)//从dp数组的首部找大于当前处理
            {						//元素的最小的元素，并替换它（贪心）
              if(nums[i] <= dp[j])//查找时可以使用二分查找，使查找的速度更快
                {
                    dp[j] = nums[i];
                    //if(j != len-1)
                    // dp.erase(dp.begin()+j+1,dp.begin()+len-1);
                    //for(int k = 0;k < len-j-1;k++)
                    // {
                    //    dp.pop_back();
                    // }

                    break;
                }
            }
        }

        if(ans < (int)dp.size())
            ans = dp.size();
    }

    return ans;
}

算法原理：

贪心加动态规划(时间复杂度为O(N*logN）)
dp数组具体维护过程同样举例讲解更为清晰。
同样对于序列 a(1, 7, 3, 5, 9, 4, 8)，dp的变化过程如下

• dp[0] = a[0] = 1，长度为1的LIS结尾元素的最小值自然没得挑，就是第一个数。 （dp = {1}）
• 对于a[1]=7，a[1]>dp[0]，因此直接添加到dp尾，dp[1]=a[1]。（dp = {1, 7}）
• 对于a[2]=3，dp[0]< a[2]< dp[1]，因此a[2]替换dp[1]，令dp[1]=a[2]，因为长度为2的LIS，结尾元素自然是3好过于7，因为越小这样有利于后续添加新元素。 （dp = {1, 3}）
• 对于a[3]=5，a[3]>dp[1]，因此直接添加到dp尾，dp[2]=a[3]。 （dp = {1, 3, 5}）
• 对于a[4]=9，a[4]>dp[2]，因此同样直接添加到dp尾，dp[3]=a[9]。 （dp = {1, 3, 5, 9}）
• 对于a[5]=4，dp[1]< a[5]< dp[2]，因此a[5]替换值为5的dp[2]，因此长度为3的LIS，结尾元素为4会比5好，越小越好嘛。（dp = {1, 3, 4, 9}）
• 对于a[6]=8，dp[2]< a[6]< dp[3]，同理a[6]替换值为9的dp[3]，道理你懂。 （dp = {1, 3, 5, 8}）

这样子dp数组就维护完毕，所求LIS长度就是dp数组长度4。
通过上述求解，可以发现dp数组是单调递增的，因此对于每一个a[i]，先判断是否可以直接插入到dp数组尾部，

即比较其与dp数组的最大值即最后一位；如果不可以，则找出dp中第一个大于等于a[i]的位置，用a[i]替换之。
这个过程可以利用二分查找，因此查找时间复杂度为O(logN)，所以总的时间复杂度为O(N*logN)