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為末元素的遞增子序列。一般在解決問題的時候都是用到動態規划，所以就貼出代碼了。主要用這個。。。。。。

代碼如下：

#include<stdio.h>//**O（n^2）
#include<string.h>
int main()
{
    char str[10001];
    int s,len,i,j,dp[10001],max;
    scanf("%d",&s);
    while(s--)
    {
        max=0;
        scanf("%s",str);
        len=strlen(str);
        for(i=0;i<=len-1;i++)
        {
            dp[i]=1;//**dp[i]的最小值為1**//
        }
        for(i=len-2;i>=0;i--)     //這點表示不太懂，正研究着。。。
        {
            for(j=i+1;j<=len-1;j++)
            {
                if(str[i]<str[j]&&dp[i]<dp[j]+1) //最長遞增子序列則a[j]>a[i],而最長遞減子序列則a[j]<a[i]...好好體會。。。
                {
                    dp[i]=dp[j]+1;//**更新dp[i]的值**//
                }
            }
        }
        for(i=0;i<=len-1;i++)
        {
            if(dp[i]>max)
            {
                max=dp[i];
            }
        }
        printf("%d\n",max);
    }
}                

 

思路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)

借鑒代碼如下：

//LIS算法實現
#include <stdio.h>
#include<string.h>
char str[10001];
int main()
{
    int T,i,j;int len,ans;
    scanf("%d",&T);
    while(T--)
    {
        memset(str,0,sizeof(str));
        scanf("%s%*c",str);
        len=strlen(str);
        ans=0;
        for(i=0;i<len;i++)
        {
            for(j=0;j<ans;j++)
                if(str[j]>=str[i]) 
                { 
                    str[j]=str[i]; 
                    break;
                }
            if(j==ans)
            {
                str[j]=str[i];
                ans++;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}