动态规划：最长上升子序列（LIS）

求解最长子序列问题通常有两种算法：

一.O(n*n)算法，dp[i]表示以ai为末尾的最长上升子序列的长度，而以ai结尾的最长上升子序列有两种：

1.只包含ai的子序列;  

2.在满足j<i且aj<ai的以aj为结尾的上升子序列末尾，追加上ai得到的子序列。

所以有如下递推关系：

dp[i]=max{1,dp[j]+1|j<i且aj<ai} 

例如：1 7 3 5 9 4 8  序列， 我们定义d(i) (i∈[1,n])来表示前i个数以A[i]结尾的最长上升子序列长度。

前一个数 d(1)=1,子序列为1；

前两个数 7前面有1小于7，d(2)=d(1)+1=2 ,子序列为1 7

前三个数 3前面有1小于3，d(3)=d(1)+1=2,子序列为1 3

前四个数 5前面有3小于5，d(4)=d(3)+1=3,子序列为1 3 5

前五个数 9前面有5小于9，d(5)=d(4)+1=4,子序列为1 3 5 9

前六个数 4前面有3小于4，d(6)=d(3)+1=3,子序列为1 3 4

前七个数 8前面有4小于8，d(7)=d(6)+1=4,子序列为1 3 4 8

d(i)=max{d(1),d(2),……,d(i)} 我们可以看出这7个数的LIS为d(7)=4或d(5)=4

我们来看一下O(n*n)算法的代码如何实现

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int a[10010],dp[10010];
int main()
{
	int n;
	while(cin>>n&&n)
	{
		for(int i=0;i<n;i++)
		{
			cin>>a[i];
			dp[i]=1;
		}
		int ans=0;
		for(int i=1;i<n;i++)
		{
			for(int j=0;j<i;j++)
			{
				if(a[j]<a[i])
				dp[i]=max(dp[j]+1,dp[i]);
			}
			ans=max(ans,dp[i]);
		}
		cout<<ans<<endl;
	}
return 0;	
} 

二.O(nlogn)算法

     由于O(n*n)算法的时间复杂度比较高，在做题方面很多题都很容易超限，现在我们来介绍另外一种O(nlogn)的算法

     我们来举一个例子 1 7 3 5 9 4 8 序列定义dp[i]=长度为i+1的上升子序列中末尾元素的最小值（不存在的话就是INF）

     前一个数，a[1]=1,dp[1]=1,此时len=1,子序列为 1

     前两个数，a[2]=7大于1,dp[2]=7,此时len=2,子序列为 1 7

     前三个数，a[3]=3小于7，3替换7，dp[2]=3,此时len=2,子序列为 1  3

     前四个数，a[4]=5大于3,dp[3]=5,此时len=3,子序列为 1 3 5

     前五个数，a[5]=9大于5,dp[4]=9,此时len=4,子序列为 1 3 5 9

     前六个数，a[6]=4小于5，4代替5,   dp[3]=4,子序列为1 3 4

     前七个数，a[7]=8小于9,用8代替9， dp[4]=8,此时len=8,子序列为 1 3 4 8

     这种算法中，运用STL中的lower_bound()函数很方便。

     我们来看一下O(n*n)算法的代码如何实现

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define INF 0x3f3f3f
using namespace std;
int a[10010],dp[10010];
int main()
{
	int n;
	while(cin>>n&&n)
	{
		for(int i=0;i<n;i++)
		{
			cin>>a[i];
		}
		fill(dp,dp+n,INF);
		for(int i=0;i<n;i++)
		{
			*lower_bound(dp,dp+n,a[i])=a[i];
		}
		int ans=lower_bound(dp,dp+n,INF)-dp;
		cout<<ans<<endl; 
	}
return 0;	
} 

下面我们来看一道例题

   

                             最少拦截系统

                                           Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
                                           Total Submission(s): 49207    Accepted Submission(s): 19264

Problem Description

某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统.但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能超过前一发的高度.某天,雷达捕捉到敌国的导弹来袭.由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹.
怎么办呢?多搞几套系统呗!你说说倒蛮容易,成本呢?成本是个大问题啊.所以俺就到这里来求救了,请帮助计算一下最少需要多少套拦截系统.

 

Input

输入若干组数据.每组数据包括:导弹总个数(正整数),导弹依此飞来的高度(雷达给出的高度数据是不大于30000的正整数,用空格分隔)

 

Output

对应每组数据输出拦截所有导弹最少要配备多少套这种导弹拦截系统.

 

Sample Input

    
    

     
     8 389 207 155 300 299 170 158 65
    
    

 

Sample Output

    
    

     
     2
    
    

AC代码如下：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define INF 0x3f3f3f
using namespace std;
int a[10010],dp[10010];
int main()
{
	int n;
	while(cin>>n&&n)
	{
		for(int i=0;i<n;i++)
		{
			cin>>a[i];
		}
		fill(dp,dp+n,INF);
		for(int i=0;i<n;i++)
		{
			*lower_bound(dp,dp+n,a[i])=a[i];
		}
		int ans=lower_bound(dp,dp+n,INF)-dp;
		cout<<ans<<endl; 
	}
return 0;	
}