动态规划4_最长上升子序列

最长上升子序列问题（LIS，Longest Increasing Subsequence）

有一个长为n的数列a0，a1，a2，.......a(n-1)。求出这个序列中最长的上升子序列的长度。

上升子序列指的是对于任意的i<j都满足ai<aj的子序列。

如 n=5

a={4，2，3，1，5}；

则最长的上升子序列长度为3，该子序列为（2，3，5）。

那如何得到状态转移方程呢？

先举个例子。n=5，a={7，3，4，2，5}；dp[i]代表是以第i个数为结束的 最长上升子序列（下面简写为LIS）的长度。

当i=0时，a[0]=7,以7结尾的LIS是{7}，长度为1，即dp[0]=1；

当i=1时，a[1]=3，因为前面的7>3，以3结尾的LIS是{7}，所以dp[1]=1;

当i=2时，a[2]=4，以4结尾，前面就不能有a[0]=7了，但是可以由a[1]=3，所以以4为结尾的LIS是{3，4}，所以dp[2]=2；

当i=3时，a[3]=2，以1结尾的LIS是{2}，所以dp[3]=1；

当i=4时，a[4]=5，以5为结尾的上升子序列（注意：不是最长上升子序列）可以是{3，5}，{3，4，5}，{2，5}。

而最长上升子序列是{3，4，5}，可以说是讨论i=2的基础在后面加上5.

从上面的分析可以得到

当讨论i时，LIS是前面i-1个最长上升子序列加上a[i]，前提是a[i]>a[j] (a[j]是前i-1个中LIS的最后一个)。

如讨论i=2时，在原来的{3}基础上加上4.讨论i=4时，在前面的LIS{3,4}基础上加上5.

所以计算dp[i]的方法是从前面的dp[j] （j<i）中找出a[i]>a[j]使得dp[i]=max(dp[j]+1),即以第i个结束的LIS。

所以状态转移方程就出来了，dp[i]=max(1,dp[j]+1) (a[i]>a[j]，i<j)前面的1是代表前面都没有a[i]>a[j]。如上例中的a[0]。

代码实现：O（n^2）

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int dp[110000];//记录以a[i]结束的最长子序列的长度
int a[110000];

int main()
{
	// freopen("in.txt","r",stdin);
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        memset(dp,0,sizeof(dp));
       
		for(int i=0;i<n;i++)
			scanf("%d",&a[i]);

		int len=1;
		for(int i=0;i<n;i++)
		{
			dp[i]=1;

			for(int j=0;j<i;j++)
			{
				if(a[i]>a[j])
					dp[i]=max(dp[i],dp[j]+1);
			}
			len=max(len,dp[i]);//更新当前最长的上升子序列
		}
		printf("%d\n",len);
    }
    return 0;
}

接下来是介绍LIS的 O（nlogn）算法，用于处理当n很大时的LIS。

方法：最开始全部dp[i]的值都初始化为INF。然后由前到后逐个考虑数列的元素，对于每个a[j]，如果i=0或者dp[i-1]<a[j]的话，

      就用dp[i]=min(dp[i],aj)进行更新。最终找出使得dp[i]<INF的最大的i+1就是结果了。

      因为对于已经有序的dp[0]<dp[1]<...dp[k]=INF,(k>=0)来说，前k+1个已经“填充”小于INF的数，即是当前长度已经记录下来了，

     然而对于即将要插入到序列的a[j]来说，如果a[j]>dp[i-1]（i-1是当前dp数列最接近a[j]且大于a[i-1]的最小下标）,将a[j]替换dp[i]。

    则原来a[j]<dp[i]，在后面比较中，由于a[j]更新，使得它找到更长的LIS可能性增加。

     对于已经有序的DP数列来说，在a[j]中找到一个最后一个小于a[j]的位置，可以用二分查找的方法实现。这样复杂度就变成O（nlogn）。

例如 n=5,a={7，3，4，2，5}；

运算过程dp数列的变化：

代码实现：

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int INF=1e9;
int dp[110000];//记录以a[i]结束的最长子序列的长度
int a[110000];


int main()
{
	// freopen("in.txt","r",stdin);
	int n;
	while(scanf("%d",&n)!=EOF&&n)
	{
		for(int i=0;i<n;i++)
			dp[i]=INF;
		for(int i=0;i<n;i++)
			scanf("%d",&a[i]);

		int len=0;
		for(int i=0;i<n;i++)
		{
			*lower_bound(dp,dp+n,a[i])=a[i];
		}
		printf("%d\n",lower_bound(dp,dp+n,INF)-dp);
	}
	return 0;
}

推荐题目：POJ 2544 POJ 3903 POJ 1631

2544直接O（n^2）就能过  3903、1631都要用O（nlogn）算法过，其中1631是T组输入。

HDU 1087

题意：找出上升自序列中累加和最大的值。

其实将状态转移方程改成 dp[i]=max(dp[i],dp[j]+a[i])即可。

代码实现：

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int dp[1100];//记录以a[i]结束的最长子序列的长度
int a[1100];

int main()
{
    // freopen("in.txt","r",stdin);
    int n;
    while(scanf("%d",&n)!=EOF&&n)
    {
        memset(dp,0,sizeof(dp));

        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);

        int len=0;
        for(int i=0;i<n;i++)
        {
            dp[i]=a[i];

            for(int j=0;j<i;j++)
            {
                if(a[i]>a[j])
                    dp[i]=max(dp[i],dp[j]+a[i]);
            }
            len=max(len,dp[i]);//更新当前最长的上升子序列
        }
        printf("%d\n",len);
    }
    return 0;
}