线性dp之序列问题

线性dp之序列问题

【基本概念与性质】

1.子序列： 一个序列 A＝a1,a2,……an 中任意删除若干项，剩余的序列叫做 A 的一个子序列。也可以认为是从序列 A 按原顺序保留任意若干项得到的序列。（例如：对序列｛1,3,5,4,2,6,8,7｝来说，序列｛3,4,8,7｝是它的一个子序列。）

2.公共子序列 ：如果序列 C 既是序列 A 的子序列，也是序列 B 的子序列，则称它为序列 A 和序列 B 的公共子序列。（例如：对序列｛1,3,5,4,2,6,8,7｝和序列｛1,4,8,6,7,5｝来说，序列｛1,8,7｝是它们的一个公共子序列）

3.最长公共子序列：A 和 B 的公共子序列中长度最长的（包含元素最多的）序列叫做 A 和 B 的公共子序列。（ 最长公共子序列不唯一）

4.对于一个长度为 n 的序列，它一共有 2^n 个子序列，有 (2^n – 1) 个非空子序列。

5.子序列不是子集，它和原始序列的元素顺序是相关的。

6.空序列是任何两个序列的公共子序列。

7.角标为 0 时，认为子序列是空序列。

【LIS问题】

LIS 问题（Longest Increasing Subsequence），最长上升子序列，其一般为求最长下降子序列或是最长上升子序列。用 DP[i] 表示 a[i] 为结尾的最长上升子序列的长度，则有状态转移方程: DP[i] = max(DP[i], DP[j]+1);

int LIS(int a[], int n)
{
    int DP[n];
    int Cnt=-1;
    memset(DP, 0, sizeof(DP));
    for(int i=0; i<n; i++ ){
        for(int j=0; j<i; j++ ){
            if( a[i]>a[j] ){
                DP[i] = max(DP[i], DP[j]+1);
                Cnt = max(DP[i], Cnt);//记录最长序列所含元素的个数
            }
        }
    }
    return Cnt+1;//因为初始化为0,所以返回结果+1
}

【LCS 问题】

LCS问题（Longest Common Subsequence），求序列的最长公共子序列，M[i][j] 表示前缀子串 x[1~i] 与 y[1~j] 的最长公共子序列的长度，则有状态转移方程：M[i][j] = max(M[i-1][j]，M[i][j-1]，M[i-1][j-1]+1（if：x[i] = y[j]））

#include <bits/stdc++.h>
using namespace std;
const int maxn = 550;

int main()
{
    char x[maxn],y[maxn];
    int M[maxn][maxn], i, j;
    while( gets(x) && gets(y) ){
        int len1 = strlen(x);
        int len2 = strlen(y);
        for( i=0; i<=len1; i++ ) M[i][0] = 0;
        for( i=0; i<=len2; i++ ) M[0][i] = 0;
        for( i=1; i<=len1; i++ ){
            for( j=1; j<=len2; j++ ){
                if( x[i-1]==y[j-1] ){
                    M[i][j] = M[i-1][j-1]+1;
                }
                else{
                    M[i][j] = max(M[i-1][j],M[i][j-1]);
                }
            }
        }
        printf("%d\n", M[len1][len2]);
    }
    return 0;
}

【LCIS 问题】

LCIS 问题（Longest Common Increasing Subsequence），求序列的最长公共上升子序列。

dp[i][j] 表示 a[1]~a[i] 和 b[1]~b[j]并以b[j]结尾的最长公共上升子序列,如果a[i]不等于b[j]时，很明显dp[i][j]的值就等于dp[i-1][j]；如果a[i]等于b[j]时，就在b[1]~b[j]中寻找b[k]使得b[j]>b[k]而且dp[i][k]是最大的。即状态转移方程为：

 

 

 

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1111;

int a[maxn],b[maxn],dp[maxn][maxn];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        dp[i][0] = 0;
    }
    for(int i=1;i<=m;i++){
        scanf("%d",&b[i]);
        dp[0][i]=0;
    }
    dp[0][0]=0;
    int max1;
    for(int i=1;i<=n;i++){
        max1=0;//用来记录小于a[i]的b[j]中最大的dp[i][j];
        for(int j=1;j<=m;j++){
            if(a[i]!=b[j]){
                dp[i][j]=dp[i-1][j];
            }
            else{
                for(int k=1;k<j;k++){
                    if( b[j]>b[k]){
                        max1 = max(max1,dp[i][k]);
                    }
                }
                dp[i][j]=max1+1;
            }
        }
    }


    int ans=0;
    for(int i=1;i<=m;i++){
        ans=max(ans,dp[n][i]);
    }
    printf("%d\n",ans);
//    printf("%d\n",dp[n][m]);
    return 0;
}

 

以上程序的复杂度为O(n^3)，n太大的话就会超时。所以应该优化一下，当a[i] == b[j]时，才去遍历寻找max1，是在b[j]>b[k]的条件下，即在a[i]>b[k]所以可以先在[1,m]里面保存好max1的值，然后当a[i] == b[j]时，就可以直接令dp[i][j] = max1+1，时间复杂度就降为O(n^2)；因此对于决策集合中的元素只增多不减少的情景，就可以维护一个变量来记录决策集合的当前消息，只需要两重循环即可求解。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1111;
int a[maxn],b[maxn],dp[maxn][maxn];

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        dp[i][0]=0;
    }
    for(int i=1;i<=m;i++){
        scanf("%d",&b[i]);
        dp[0][i]=0;
    }
    int max1;
    dp[0][0]=0;
    for(int i=1;i<=n;i++){
        max1=0;
        for(int j=1;j<=m;j++){
            if( a[i]!=b[j] ){
                dp[i][j]=dp[i-1][j];
            }
            else{
                dp[i][j]=max1+1;
            }
            if( a[i]>b[j] && max1<dp[i][j]){
                max1 = dp[i][j];
            }
        }
    }

    int ans=0;
    for(int i=1;i<=m;i++){
        ans=max(ans,dp[n][i]);
    }
    printf("%d\n",ans);
    return 0;
}

 

观察状态转移方程可以进行通过滚动数组压缩空间；即状态转移方程为：dp[j] = max(dp[k])+1(1<=k<j && b[j]>b[k])

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1111;
int a[maxn],b[maxn],dp[maxn];

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    for(int i=1;i<=m;i++){
        scanf("%d",&b[i]);
        dp[i]=0;
    }
    int max1;
    for(int i=1;i<=n;i++){
        max1 = 0;
        for(int j=1;j<=m;j++){
            if( a[i]==b[j] ){
                dp[j]=max1+1;
            }
            if( a[i]>b[j] && max1<dp[j] ){
                max1 = dp[j];
            }
        }
    }

    int ans=0;
    for(int i=1;i<=m;i++){
        ans=max(ans,dp[i]);
    }
    printf("%d\n",ans);
    return 0;
}