最长递增子序列

这是一道百度常用面试题。

举例：arr = [2, 1, 5, 3, 6, 4, 8, 9, 7], 返回的最长递增子序列为 [1, 3, 4, 8, 9]。

1. 动态规划解法

O(N2)思路如下：

1. 构造dp：生成长度为N的数组dp，dp[i]表示在以arr[i]这个数结尾的情况下，arr[0...i]中的最大递增序列长度；
2. 首元素：对第一个数arr[0]来说，令dp[0] = 1,接下来，从左到右依次计算出每个数结尾的情况下的最长递增序列长度；
3. 迭代：计算dp[i]，如果最长递增子序列以arr[i]结尾，那么arr[0,...,i-1]中所有比arr[i]小的数都可以作为倒数第二个数。所以 dp[i] = max{ dp[j] + 1} (0 <=j < i, arr[j] < arr[i])， 如果arr[0,...,i-1]中所有数都不比arr[i]小，令dp[i] = 1；
4. 根据求出的dp数组，得到最长递增子序列，遍历dp数组，找到最大值以及位置，并开始逆序还原出决策路径。

代码实现

 int main() {
    vector<int> arr;
    int temp;
    while(cin >> temp){
        arr.push_back(temp);
    }
    vector<int> dp = getdp1(arr);
    vector<int> lis = generateLIS(arr, dp);
    for (int i = 0; i < lis.size(); i++){
        cout << lis[i]<<" ";
    }
    return 0;
} 
vector<int> getdp1(vector<int> &arr){
    vector<int> dp(arr.size(), 0);
    for(int i = 0; i < arr.size(); i++){
        dp[i] = 1;
        for (int j = 0; j < i; j++){
            if (arr[j] < arr[i]){
                dp[i] = max(dp[j]+ 1, dp[i]);
            }
        }
    }
    return dp;
}
vector<int> generateLIS(vector<int> &arr, vector<int> &dp){
    int len = 0; int index = 0;
    for (int i = 0; i < dp.size(); i++) { //寻最长递增子序列末尾的位置和值
        if (dp[i] > len) {
            len = dp[i];              // 最长序列长度
            index = i;                // 最长序列末位置
        }
    }
    vector<int> lis(len, 0);
    lis[--len] = arr[index];
    for (int i = index; i >= 0; i--){
        if (arr[i] < arr[index] && dp[i] == dp[index] - 1){  //从后往前找子序列
            lis[--len] = arr[i];
            index = i;
        }
    }
    return lis;
}

2. 二分法

O(NlogN)的方法，具体过程如下：

先生成一个长度为N的数组ends和变量right，遍历的过程中ends[0,...,right]有效区，ends[right+1,...,N-1]无效区，

ends[b] = c 表示遍历到目前为止，在所有长度为b+1的递增序列中，最小的结尾数为c。

以arr=[2,1,5,3,6,4,8,9,7]为例进行说明：

1. 初始时，dp[0]=1, ends[0]=2, rights = 0, 有效区 ends[0...0],ends[0] = 2, 长度为1，结尾为2；

2. arr[1] = 1, 在有效区ends[0,...0]找最左边大于或等于arr[1]的数，发现ends[0] =2 >arr[1], 表示以arr[1]结尾的最长序列只有

    一 个，dp[1] = 1, ends[0] = 1 (用1替换了原来的2)；

3. arr[2] = 5, 在有效区ends[0,..0]找最左边大于或等于arr[2]的数，发现并没有，则ends的有效长度+1， end[1] = 5, 有效区

   扩大，dp[2] = 2. arr[0,1] = {1, 5}；

依此类推

代码实现

// 最长递增序列 <动态规划> <复杂度0(NlogN)>
#include<bits/stdc++.h>
using namespace std;
vector<int> getdp2(vector<int> &arr);
vector<int> generateLIS(vector<int> &arr, vector<int>&dp);
 
 
int main() {
    vector<int> arr;
    int temp;
    while(cin >> temp){
        arr.push_back(temp);
    }
    vector<int> dp = getdp2(arr);
    vector<int> lis = generateLIS(arr, dp);
    for (int i = 0; i < lis.size(); i++){
        cout << lis[i]<<" ";
    }
    return 0;
}
 
 
vector<int> getdp2(vector<int> &arr){
    vector<int> dp(arr.size(), 0);
    vector<int> ends(arr.size(), 0);
    ends[0] = arr[0]; dp[0] = 1;
    int right = 0; int l = 0; int r = 0; int m = 0;
    for (int i = 1; i < arr.size(); i++) {
        l = 0;
        r = right;
        while(l <= r) {      //二分法
            m = (l + r) / 2;
            if (arr[i] > ends[m]){
                l = m + 1;
            }else {
                r = m - 1;
            }
        }
        right = max(right, l);
        ends[l] = arr[i];
        dp[i] = l + 1;
    }
    return dp;
}
 
 
vector<int> generateLIS(vector<int> &arr, vector<int> &dp){
    int len = 0; int index = 0;
    for (int i = 0; i < dp.size(); i++) { //寻最长递增子序列末尾的位置和值
        if (dp[i] > len) {
            len = dp[i];
            index = i;
        }
    }
    vector<int> lis(len, 0);
    lis[--len] = arr[index];
    for (int i = index; i >= 0; i--){
        if (arr[i] < arr[index] && dp[i] == dp[index] - 1){  //从后往前找子序列
            lis[--len] = arr[i];
            index = i;
        }
    }
    return lis;
}