杭电1423（最长递增公共子序列 LICS）

Greatest Common Increasing Subsequence

Time Limit: 2000/1000 MS (Java/Others)
Memory Limit: 65536/32768 K (Java/Others)

Problem Description

This is a problem from ZOJ 2432.To make it easyer,you just need output the length of the subsequence.

Input

Each sequence is described with M - its length (1 <= M <= 500) and M integer numbers Ai (-2^31 <= Ai < 2^31) - the sequence itself.

Output

output print L - the length of the greatest common increasing subsequence of both sequences.

Sample Input

1

5
1 4 2 5 -12
4
-12 1 2 4

Sample Output

2

思路：

本题为最长递增公共子序列，套用模板。
递推公式为：

• 令dp[i][j]为以s2串的j为终点的最长公共上升子序列的长度。
• s1[i] != s2[j]：dp[i][j] = dp[i-1][j]
• s1[i] == s2[j]：dp[i][j] = max(dp[i - 1][k])+1 s2[i] > s2[k] && 1<= k < j )

优化：

• 当s1[i] > s2[j] 时，令ans = dp[i][j]；
• 当s1[i] = s2[j] 时，令dp[i][j] = ans + 1；
• 最后答案为dp[len(s1)][1] … dp[len(s1)][len(s2)]的最大值。

再优化：

• 当i循环到x时，用dp[i]代替dp[i][j]，因为当s1[i] != s2[j] 时，dp[x][j] = dp[x-1][j]值不变，所以dp[x]不用改变，只需要维护ans的值
• 当s1[i] > s2[j] 时，令ans = dp[j]；
• 当s1[i] = s2[j] 时，令dp[j] = ans + 1；
• 最后答案为dp[i]和ans的最大值。

AC代码：

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;

int s1[550],s2[550];
int dp[550];

int LICS(int n1,int n2)
{
    memset(dp,0,sizeof(dp));
    int ans;
    for(int i=0;i<n1;i++)
    {
        ans=0;
        for(int j=0;j<n2;j++)
        {
            if(s1[i]>s2[j]&&ans<dp[j]) ans=dp[j];
            if(s1[i]==s2[j]) dp[j]=ans+1;
        }
    }
    ans=0;
    for(int i=0;i<n1;i++)
    {
        ans=max(ans,dp[i]);
    }
    return ans;
}

int main()
{
    int n1,n2;
    int t;
    cin>>t;
    while(t--) 
    {
        cin>>n1;
        for(int j=0;j<n1;j++)
        {
            cin>>s1[j];
        }
        cin>>n2;
        for(int j=0;j<n2;j++)
        {
            cin>>s2[j];
        }
        cout<<LICS(n1,n2)<<endl;
        if(t!=0) cout<<endl;
    }
    return 0;
}