【算法知识总结】最长递增子序列

最长递增子序列：
找到给定序列的最长子序列的长度，使得子序列所有元素单调递增。

解法一 转化为求最长公共子序列

• 设数组{3，5，7，1，2，8}为A
• 对数组A排序，排序后为B={1，2，3，5，7，8}。
• 求A数组的最长递增子序列，就是求数组A与数组B的最长公共子序列

最长公共子序列求法的时间复杂度：
$\theta(nlgn)+\theta(n^2)=\theta(n^2)$

解法二 动态规划法

与第一个办法不同的是，动态规划是直接在原问题上采用动态规划
最优子结构：
对于长度为N的数组$A[N]=\{a_0,a_1,a_2,a_3,a_3,...,a_{n-1}\}$，假设我们想要以$a_i$结尾的最大递增子序列长度，设长度$L[i]$ ，那么

$$L[i]=\begin{cases} max(L[j])+1, & where \ j<i \ and \ A[j]<A[i] \\ 1,& otherwise \end{cases}$$
也就是 $j$的范围是$0$到 $i-1$。这样，想求 $a_i$结尾的最大递增子序列的长度，我们就需要遍历 $i$之前的所有位置$j(0到i-1)$，找出 $A[j]<A[i]$，计算这些 $j$中，能产生最大$L[j]中的j$，之后就可以求出 $L[i]$。之后对每一个 $A[N]$中的元素都计算以他们各自结尾的最大递增子序列长度，这些长度的最大值，就是我们要求的问题数组 $A$的最大递增子序列的长度
重叠问题：
根据上面公式的推导采用递归实现的话，有一些子问题就会被计算很多次。
动态规划法：
综上所述：LIS问题具有动态规划需要的两个性质，可以使用动态规划求解该问题。设数组 $A=\{3,5,7,1,2,8\}$，则：

---

具体打表方式如下：

• 
  
• 初始化对角线为 1；
• 对每一个$i，遍历 j（0 到 i-1）$：
  

• 若$A[i] <= A[j]$，置 1。
  
• 若$A[i] > A[j]$，取第$j$ 行的最大值加 1。
  打完表以后，最后一行的最大值就是最长递增子序列的长度。由于每次都进行遍历，故时间复杂度还是 $\theta(n^{2})$。

//LIS 的动态规划方式实现  
include <iostream>  
using namespace std;  
int getLISLength(int A[], int len) {  
   //定义一维数组并初始化为1  
   int* lis = new int[len];    
   for (int i = 0; i < len; ++i)   
      lis[i] = 1;  

   // 计算每个i对应的lis最大值，即打表的过程  
   for (int i = 1; i < len; ++i)  
      for (int j = 0; j < i; ++j)     // 0到i-1  
         if ( A[i] > A[j] && lis[i] < lis[j] + 1)  
            lis[i] = lis[j] + 1;  // 更新  

   // 数组中最大的那个，就是最长递增子序列的长度  
   int maxlis = 0;  
   for (int i = 0; i < len; ++i)  
      if ( maxlis < lis[i] )  
         maxlis = lis[i];  

   delete [] lis;  
   return maxlis;  
}  

解法三 $\theta(nlgn)$的方案

本解法的具体操作如下：

• 
  
• 建立一个辅助数组array，依次读取数组元素 x 与数组末尾元素 top比较：
  

• 如果 x > top，将 x 放到数组末尾；
  
• 如果 x < top，则二分查找数组中第一个 大于等于x 的数，并用 x 替换它.

遍历结束之后，最长递增序列长度即为栈的大小。
注意c数组的下标代表的是子序列的长度，c数组中的值也是按递增顺序排列的。这才可能用二分查找。

int getLISLength(int num[], int length) {  
    vector<int> ivec;  
    for (int i = 0; i < length; ++i) {  
        if (ivec.size() == 0 || ivec.back() < num[i])  
            ivec.push_back(num[i]);  
        else {  
            int low = 0, high = ivec.size() - 1;  
            while (low < high) {  
                int mid = (low + high) / 2;  
                if (ivec[mid] < num[i])  
                    low = mid + 1;  
                else  
                    high = mid - 1;  
            }  
            ivec[low] =  num[i];  
        }  
    }  
    return ivec.size();  

特别注意的是：本方法只能用于求最长递增子序列的长度，辅助数组中的序列不是最长递增子序列：

• 例一：原序列为1，5，8，3，6，7
  辅助数组为1，5，8，此时读到3，用3替换5，得到1，3，8； 再读6，用6替换8，得到1，3，6；再读7，得到最终栈为1，3，6，7。最长递增子序列为长度4。
• 例二：原序列为1，5，8，3
  则最栈辅助数组为1，3，8。明显这不是最长递增子序列！

合唱队问题

问题描述：
计算最少出列多少位同学，使得剩下的同学排成合唱队形
问题说明：
$N$位同学站成一排，音乐老师要请其中的$(N-K)$位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设$K$位同学从左到右依次编号为$1，2…，K，$他们的身高分别为$T_1，T_2，…，T_K，$ 则他们的身高满足存在$i（1<=i<=K）$使得$T_1<T_2<......<T_{i-1}<T_i>T_{i+1}>......>T_K$。
任务是:
已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
输入：
整数$N$，一行整数，空格隔开，$N$位同学身高
输出：
最少需要几位同学出列
样例输入：

8
186 186 150 200 160 130 197 200

样例输出：

4

根据题意可知，我们需要求出一个“中间点”，使得其左边的【最长递增子序列】和其右边的【最长递减子序列】之和最大。

```
#include <iostream>    
#include <vector>    
using namespace std;    

int LonggestIncreaseLength(vector<int> &vec) {    
    vector<int> result(vec.size(), 1);    
    vector<int> result2(vec.size(), 1);    
    for (int i = 1; i < vec.size(); i++) {    
        for (int j = 0; j < i; j++) {    
            if (vec[i] > vec[j] && result[i] < result[j] + 1)    
                result[i] = result[j] + 1;    
        }    
    }    

    for (int i = vec.size() - 2; i >= 0; --i) {    
        for (int j = vec.size() - 1; j > i; --j) {    
            if (vec[i] > vec[j] && result2[i] < result2[j] + 1)    
                result2[i] = result2[j] + 1;    
        }    
    }    
    int max = 0;    
    for (int i = 0; i < vec.size(); i++) {    
        if (max < result[i] + result2[i])    
            max = result[i] + result2[i];    
    }    
    return vec.size() - max + 1;    
}    
int main() {    
    int n;    
    cin >> n;    
    if (n <= 0)    
        return 0;    
    vector<int> ivec(n);    
    for (int i = 0; i < n; i++)    
        cin >> ivec[i];    
    cout << LonggestIncreaseLength(ivec) << endl;    
}