最长递增子序列（LIS）

本篇博客主要讲述什么是最长公共子序列、求解最长公共子序列的思想，以及代码。

什么是最长公共子序列？

  给定一个长度为N的数组，找出一个最长的单调自增子序列（不要求是连续的）。例如：6 5 7 8 4 3 9 1，这里的最长递增子序列是{ 6， 7， 8， 9}或者{5， 7， 8， 9}。可以看出最长递增子序列不唯一，但是长度一定是唯一的，不然也不能叫最长递增子序列。

动态规划的思想实现:

if(a[i] > a[j] && dp[i] < dp[j] + 1)
                dp[i] = dp[j] + 1;

要求第i个递增子序列，就得先求第i-1，求第i-1个就得求i-2.....以此类推，实现方法就是不断遍历，去查找i前面的每一个dp,然后去进行比较，如果满足以上条件就进行跟新。

void LIS()
{
    for(int i = 0; i < n; i++)//初始化dp[i] = 1;
    {
        dp[i] = 1;
    }
    for(int i = 1; i < n; i++)//遍历
    {
        for(int j = 0; j < i; j++)//从i前面的查找
        {
            if(a[i] > a[j] && dp[i] < dp[j] + 1)//dp[i] < dp[j] + 1的作用就是更新最大的一个递增
                dp[i] = dp[j] + 1;
        }
    }
}

二分的思想实现：

  提到二分的思想就不得不想到STL中比较好用的lower_bound（start，end， elem）函数，lowe_bound的作用就是利用二分的思想去查找第一个小于等于elem的数。

  二分上的思想去实现最长递增子序列它的时间复杂度是O（N * logN），在第二种算法中，在计算每一个dp(i)时，都要找出最大的dp(j)(j<i)来，由于dp(j)没有顺序，只能顺序查找满足aj<ai最大的dp(j)，如果能将让f(j)有序，就可以使用二分查找，这样算法的时间复杂度就可能降到O(nlogn)。于是想到用一个数组B来存储“子序列的”最大递增子序列的最末元素，即有B[dp(j)] = aj在计算f(i)时，在数组B中用二分查找法找到满足j<i且B[dp(j)]=aj<ai的最大的j,并将B[dp[j]+1]置为ai。

其实就是相当于，在B中先更新一个，然后在跟新第i个，然后在B中查找有第i在元素比在哪个位置的元素大，如果i个元素元素的元素比最后一个大那么最后一个元素添加到最后位置，如果在中间的话，就用第i个元素取代第B中第一个大于等于它的那个数的位置。

void LIS()
{
    for(int i = 0; i < n; i++)
    {

        dp[i] = INF;
    }
    for(int i = 0; i < n; i++)
    {
        *lower_bound(dp, dp + n, a[i]) = a[i];
    }
}

例题：

最少拦截系统 hdu 1257

链接：http://acm.hdu.edu.cn/showproblem.php?pid=1257

状态规划：

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
#define N 100000
int a[N], dp[N];
int main(){
    int n;
    while(~scanf("%d", &n)){
        for(int i = 0; i < n; i++){
        cin>>a[i];
        dp[i] = 1;
    }
    for(int i = 1; i < n; i++){
        for(int j = 0; j < i; j++){
          if(a[i] > a[j] && dp[i] < dp[j] + 1)
                dp[i] = dp[j] + 1;
        }
    }
    int maxx = -1;
    for(int i = 0; i < n; i++){
        if(dp[i] > maxx){
            maxx = dp[i];
        }
    }
    cout<<maxx<<endl;
    }

return 0;
}

二分：

#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
#define N 100000
#define INF 10000000
int a[N], dp[N];
int main(){
    int n;
    while(~scanf("%d", &n)){
        for(int i = 0; i < n; i++){
            cin>>a[i];
            dp[i] = INF;
        }
        for(int i = 0; i < n; i++){
            *lower_bound(dp, dp + n, a[i]) = a[i];
        }
        cout<<lower_bound(dp, dp+n, INF) - dp<<endl;
    }
return 0;
}