NYOJ 17 单调递增最长子序列（经典dp）

地址：http://acm.nyist.net/JudgeOnline/problem.php?pid=17

题目分析：同NYOJ 79 拦截导弹 

先解释下什么叫子序列。若a序列删去其中若干个元素后与b序列完全相同，则称b是a的子序列。

我们假定存在一个单调序列{An}（以递增序列为例)，现在在其后面添加一个元素a(n+1)，有两种情况：

1.a(n+1)>a(n)   。此时，a(n+1)可以添加到An序列的尾部，形成一个新的单调序列，并且此序列长度大于之前An的长度；

2.a(n+1)<=a(n)。此时，a(n+1）当然不可以添加到An序列的尾部。

经过分析，我们可以得出这样的结论：一个单调序列与其后面元素的关系仅与此序列的末尾元素有关。

如此，便有了此题如下的dp解法：

建立一个一维数组dp[ ]，用dp[i]保存长度为i的单调子序列的末尾元素的值，用top保存单调子序列的最大长度。

初始top=1，dp[1]=a1；

然后，我们从前向后遍历序列An（i : 2~n)。显然，我们会遇到两种情况：

1.a[i] > dp[top]。此时，我们把a[i]加入到长度为top的单调序列中，这时序列长度为top+1，top值也跟着更新，即dp[++top] = a[i]；

2.a[i]<=dp[top]。此时，a[i]不能加入长度为top的单调序列，那它应该加入长度为多少的序列呢？

   做法是，从后向前遍历dp[ ] (j: top-1~1)，直到满足条件 a[i] > dp[j]，此时，类似于步骤1，我们可以把a[i]加入到长度为j的单调序列中，这时此序列长度为j+1，

   我们将dp[j+1]的值更新为a[i]。可是，为什么要更新它呢？

   因为a[i]一定小于dp[j+1]。为什么呢？如果a[i]不小于dp[j+1]，我们找到的j就应该是j+1而不是j。那么，我们为什么要保留把dp[j+1]的最小值呢？

   因为对于相同长度的单调递增序列来说，末尾元素的值越小，其后元素加入此序列的可能性越大，也就是说，我们这样做，是为了防止丢失最优解。

 

思路1：

      这题其实是跟导弹拦截一样的，因为还有个加强版，所以把这个跟加强版一起贴上来。经典动态规划题,以后的动态规划很多都是从这个衍生出来的

一 最长递增子序列问题的描述

　　设L=<a₁,a₂,…,a_n>是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=<a_K1,a_k2,…,a_km>，其中k₁<k₂<…<k_m且a_K1<a_k2<…<a_km。求最大的m值。

     假设L是字符串长度，i是字符串下标，f(i)代表 当前以S[i]为首字母的字符串最大长度， 递推公式：f(i)=max(f(i+1),f(i+2),...,f(L-1),f(L))+1；用一个int dp[i]数组保存当前的f(i)值，可想而知最后 *max_element(dp,dp+L) 便得到了答案。

二 算法：动态规划法:O(n^2)

　　设f(i)表示L中以a_i为末元素的最长递增子序列的长度。则有如下的递推方程：

     f(i)=max(f(i+1),f(i+2),...,f(L-1),f(L))+1；用一个int dp[i]数组保存当前的f(i)值，可想而知最后 *max_element(dp,dp+L) 便得到了答案

     这个递推方程的意思是，在求以a_i为末元素的最长递增子序列时，找到所有序号在L前面且小于a_i的元素a_j，即j<i且a_j<a_i。如果这样的元素存在，那么对所有a_j,都有一个以a_j为末元素的最长递增子序列的长度f(j)，把其中最大的f(j)选出来，那么f(i)就等于最大的f(j)加上1，即以a_i为末元素的最长递增子序列，等于以使f(j)最大的那个a_j为末元素的递增子序列最末再加上a_i；如果这样的元素不存在，那么a_i自身构成一个长度为1的以a_i为末元素的递增子序列。一般在解决问题的时候都是用到动态规划，所以就贴出代码了。主要用这个。。。。。。

代码如下：

 1 #include<stdio.h>//**O（n^2）

 2 #include<string.h>

 3 int main()

 4 {

 5     char str[10001];

 6     int s,len,i,j,dp[10001],max;

 7     scanf("%d",&s);

 8     while(s--)

 9     {

10         max=0;

11         scanf("%s",str);

12         len=strlen(str);

13         for(i=0;i<=len-1;i++)

14         {

15             dp[i]=1;//**dp[i]的最小值为1**//

16         }

17         for(i=len-2;i>=0;i--)     //这点表示不太懂，正研究着。。。

18         {

19             for(j=i+1;j<=len-1;j++)

20             {

21                 if(str[i]<str[j]&&dp[i]<dp[j]+1) //最长递增子序列则a[j]>a[i],而最长递减子序列则a[j]<a[i]...好好体会。。。

22                 {

23                     dp[i]=dp[j]+1;//**更新dp[i]的值**//

24                 }

25             }

26         }

27         for(i=0;i<=len-1;i++)

28         {

29             if(dp[i]>max)

30             {

31                 max=dp[i];

32             }

33         }

34         printf("%d\n",max);

35     }

36 }                

 

思路2：

LIS算法(最长上升子序列)

LIS（Longest Increasing Subsequence）最长上升（不下降）子序列，有两种算法复杂度为O(n*logn)和O(n^2)。在上述算法中，若使用朴素的顺序查找在D1..Dlen查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的时间复杂度为O(n^2)，与原来算法相比没有任何进步。但是由于D的特点(2)，在D中查找时，可以使用二分查找高效地完成，则整个算法时间复杂度下降为O(nlogn)，有了非常显著的提高。需要注意的是，D在算法结束后记录的并不是一个符合题意的最长上升子序列！算法还可以扩展到整个最长子序列系列问题。

有两种算法复杂度为O(n*logn)和O(n^2)

借鉴代码如下：

 1 //LIS算法实现

 2 #include <stdio.h>

 3 #include<string.h>

 4 char str[10001];

 5 int main()

 6 {

 7     int T,i,j;int len,ans;

 8     scanf("%d",&T);

 9     while(T--)

10     {

11         memset(str,0,sizeof(str));

12         scanf("%s%*c",str);

13         len=strlen(str);

14         ans=0;

15         for(i=0;i<len;i++)

16         {

17             for(j=0;j<ans;j++)

18                 if(str[j]>=str[i]) 

19                 { 

20                     str[j]=str[i]; 

21                     break;

22                 }

23             if(j==ans)

24             {

25                 str[j]=str[i];

26                 ans++;

27             }

28         }

29         printf("%d\n",ans);

30     }

31     return 0;

32 }