Lintcode--010(最长上升子序列）

时间：2016-09-02 23:09:56 阅读：220 评论：0 收藏：0 [点我收藏+]

给定一个整数序列，找到最长上升子序列（LIS），返回LIS的长度。LIS(longestIncreasingSubsequence)

说明：

最长上升子序列的定义：

最长上升子序列问题是在一个无序的给定序列中找到一个尽可能长的由低到高排列的子序列，这种子序列不一定是连续的或者唯一的。
最长上升子序列问题，也就是Longest increasing subsequence，缩写为LIS。是指在一个序列中求长度最长的一个上升子序列的问题，是动态规划中一个相当经典问题。在这里我们可以看到，这个上升实质上就是一个对<进行定义的过程，所以我们求解的其实是一类问题，也就是在给定序列中求解长度最长的符合某一性质的子序列的问题。

样例

给出 [5,4,1,2,3]，LIS 是 [1,2,3]，返回 3
给出 [4,2,4,5,3,7]，LIS 是 [2,4,5,7]，返回 4

挑战

要求时间复杂度为O(n^2) 或者 O(nlogn)

标签

解题，分析：

如果能求解出最长上升子序列，那么再返回它的长度就可以了。

想法１：可以先对所有数字大小排序，第一次先找到最小的数以及它所在的位置，然后从这个为止向后寻找，如果后面的数字，大于它，则num+1，直到结束；

　　　然后对第二小的数字，在再次执行上面的操作，如果统计出num小于第一次的那么就保持第一次的不变，如果大于就替换成第二次的数。

　　　.........

直到结束。　　这样复杂度太高了＝＝！

想法２：动态规划求解。（重点掌握）

dp[i]表示以i结尾的子序列中LIS的长度。然后我用dp[j](0<=j<i)来表示在i之前的LIS的长度。然后我们可以看到，只有当a[i]>a[j]的时候，我们需要进行判断，是否将a[i]加入到dp[j]当中。为了保证我们每次加入都是得到一个最优的LIS，有两点需要注意：第一，每一次，a[i]都应当加入最大的那个dp[j]，保证局部性质最优，也就是我们需要找到max(dp[j](0<=j<i))；第二，每一次加入之后，我们都应当更新dp[j]的值，显然，dp[i]=dp[j]+1。
如果写成递推公式，我们可以得到dp[i]=max(dp[j](0<=j<i))+(a[i]>a[j]?1:0)。
于是我们就能够得到O(n^2)的动态规划方法。

class Solution {
public:
    /**
     * @param nums: The integer array
     * @return: The length of LIS (longest increasing subsequence)
     */
    int longestIncreasingSubsequence(vector<int> nums) {
        // write your code here

        int n=nums.size();
        int dp[n];
        memset(dp,0,sizeof(dp));
        
        int Max;
        for(int i=0;i<n;i++){
            Max=0;
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]){
                    Max=max(Max,dp[j]);
                }
            }
            dp[i]=Max+1;
        }
        Max=0;
        for(int i=0;i<n;i++){
            if(dp[i]>Max){
                Max=dp[i];
            }
        }
        return Max;
    }
};

上面的方法，我们花费了很多时间在寻找最大的dp[j]上。如果有办法让这个dp[j]变成一个递增的序列，我们就能使用二分来进行优化，从而使得复杂度下降为O(nlogn)了。

方法３：排序+LCS算法（也不错，学以致用）

方法４：动态规划＋二分法（效率最高）

转自：https://www.felix021.com/blog/read.php?1587
假设存在一个序列d[1..9] = 2 1 5 3 6 4 8 9 7，可以看出来它的LIS长度为5。
下面一步一步试着找出它。
我们定义一个序列B，然后令 i = 1 to 9 逐个考察这个序列。
此外，我们用一个变量Len来记录现在最长算到多少了

首先，把d[1]有序地放到B里，令B[1] = 2，就是说当只有1一个数字2的时候，长度为1的LIS的最小末尾是2。这时Len=1

然后，把d[2]有序地放到B里，令B[1] = 1，就是说长度为1的LIS的最小末尾是1，d[1]=2已经没用了，很容易理解吧。这时Len=1

接着，d[3] = 5，d[3]>B[1]，所以令B[1+1]=B[2]=d[3]=5，就是说长度为2的LIS的最小末尾是5，很容易理解吧。这时候B[1..2] = 1, 5，Len＝2

再来，d[4] = 3，它正好加在1,5之间，放在1的位置显然不合适，因为1小于3，长度为1的LIS最小末尾应该是1，这样很容易推知，长度为2的LIS最小末尾是3，于是可以把5淘汰掉，这时候B[1..2] = 1, 3，Len = 2

继续，d[5] = 6，它在3后面，因为B[2] = 3, 而6在3后面，于是很容易可以推知B[3] = 6, 这时B[1..3] = 1, 3, 6，还是很容易理解吧？ Len = 3 了噢。

第6个, d[6] = 4，你看它在3和6之间，于是我们就可以把6替换掉，得到B[3] = 4。B[1..3] = 1, 3, 4， Len继续等于3

第7个, d[7] = 8，它很大，比4大，嗯。于是B[4] = 8。Len变成4了

第8个, d[8] = 9，得到B[5] = 9，嗯。Len继续增大，到5了。

最后一个, d[9] = 7，它在B[3] = 4和B[4] = 8之间，所以我们知道，最新的B[4] =7，B[1..5] = 1, 3, 4, 7, 9，Len = 5。

于是我们知道了LIS的长度为5。

!!!!! 注意。这个1,3,4,7,9不是LIS，它只是存储的对应长度LIS的最小末尾。有了这个末尾，我们就可以一个一个地插入数据。虽然最后一个d[9] = 7更新进去对于这组数据没有什么意义，但是如果后面再出现两个数字 8 和 9，那么就可以把8更新到d[5], 9更新到d[6]，得出LIS的长度为6。

然后应该发现一件事情了：在B中插入数据是有序的，而且是进行替换而不需要挪动——也就是说，我们可以使用二分查找，将每一个数字的插入时间优化到O(logN)~~~~~于是算法的时间复杂度就降低到了O(NlogN)～！

代码：

//在非递减序列 arr[s..e]（闭区间）上二分查找第一个大于等于key的位置，如果都小于key，就返回e+1
int upper_bound(int arr[], int s, int e, int key)
{
    int mid;
    if (arr[e] <= key)
        return e + 1;
    while (s < e)
    {
        mid = s + (e - s) / 2;
        if (arr[mid] <= key)
            s = mid + 1;
        else
            e = mid;
    }
    return s;
}

int LIS(int d[], int n)
{
    int i = 0, len = 1, *end = (int *)alloca(sizeof(int) * (n + 1));
    end[1] = d[0]; //初始化：长度为1的LIS末尾为d[0]
    for (i = 1; i < n; i++)
    {
        int pos = upper_bound(end, 1, len, d[i]); //找到插入位置
        end[pos] = d[i];
        if (len < pos) //按需要更新LIS长度
            len = pos;
    }
    return len;
}

另一种实现代码：

class Solution {
public:
    /**
     * @param nums: The integer array
     * @return: The length of LIS (longest increasing subsequence)
     */
    int longestIncreasingSubsequence(vector<int> nums) {
        // write your code here

        int n=nums.size();
        int dp[n];
        if(n==0){
            return 0;
        }
        memset(dp,0,sizeof(int)*n);
        int len=1;
        dp[0]=nums[0];
        
        for(int i=1;i<n;i++){
            int pos=lower_bound(dp,dp+len,nums[i])-dp;
            dp[pos]=nums[i];
            len=max(len,pos+1);
        }
        return len;
    }
};

在第二种方法中，我们花费了很多时间在寻找最大的dp[j]上。如果有办法让这个dp[j]变成一个递增的序列，我们就能使用二分来进行优化，从而使得复杂度下降为O(nlogn)了。
幸运的是，这种方法确实是存在的。我们可以使用dp[i]来保存在前i个数中最大的那个数，很容易可以理解，这个dp[i]已经是单调不减的。接下来的处理其实有些贪心的思想，对于每一个a[i]，我们都在dp数组中寻找比它大的第一个数的下标，不妨设为pos，然后用a[i]来更新dp[pos]。于是我们可以明白，len就应当是max(len, pos+1)。

在这里我们使用lower_bound函数，这个函数将会返回小于等于val的第一个值的指针，如果不存在就返回end指针。

Lintcode--010(最长上升子序列）

原文：http://www.cnblogs.com/Allen-rg/p/5835807.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)