子序列问题

最长公共子序列

例：求两个字符串最长公共子序列长度。
如a[] = {"abcedf"}, b[] = {"abtrenf}，则最长公共子序列为abef,长度为4

伪代码：

for(i...a[]的长度)
    for(j...b[]的长度)
    {
        dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
            if(a[i] == b[j])
                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
    }
    输出dp[a[]的长度][b[]的长度]

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxn = 250;
int dp[maxn][maxn];
char a[maxn], b[maxn];
int main()
{
    scanf("%s%s", a + 1, b + 1);    
    /*a + 1意思是从a[1]开始读入，而并非从a[0]，这么做是
    为了后面dp时dp[i][j - 1]不越界 。但相应的后面循环就
    要从 i = 1到 i = la,而不是到 i = la - 1*/
    int la = strlen(a + 1), lb = strlen(b + 1);
    for(int i = 1; i <= la; ++i)
    {
        for(int j = 1; j <= lb; ++j)
        {
            dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
            if(a[i] == b[j])
                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
        }
    }
    printf("%d\n", dp[la][lb]);
    return 0;
}

这是子序列的一个最基本的问题，从这个问题可以衍生出很多相关的子序列问题。

最长回文子序列

例：有一个字符串，求最少删去几个字符，使它成为一个回文字符串。

思路：转化为求最长公共子序列问题：将这个字符串倒序存入另一个字符串，求这两个字符串的最长公共子序列

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxn = 250;
int n ,dp[maxn][maxn];
char a[maxn], b[maxn];
int main()
{
    scanf("%d", &n);
    scanf("%s", a + 1);
    for(int i = 1; i <= n; ++i)
        b[i] = a[n - i + 1];
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= n; ++j)
        {
            dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
            if(a[i] == b[j])
                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
        }
    }
    printf("%d\n", dp[n][n]);
    return 0;
}

最长单调子序列

例：有一个整形数组，求他的最长递增（递减）子序列。

思路：转化为求最长公共子序列问题：将这个数组排序，存到另一个数组中，求这两个数组的最长公共子序列。
这个方法空间复杂度为O(2n),可以改进为O(n)。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
const int maxn = 10005;
int a[maxn], b[maxn];
int dp[maxn][maxn], n;
int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i)
    {
        scanf("%d", &a[i]);
        b[i] = a[i];
    }
    sort(b + 1, b + n + 1);
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= n; ++j)
        {
            dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
            if(a[i] == b[j])
                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
        }
    }
    printf("%d\n", dp[n][n]);
    return 0;
}

改进：设dp[i]表示以a[i]为终点的最长上升子序列的长度，则当a[j] < a[i],且j < i时，dp[i] = dp[j] + 1.
所以dp方程：
dp[i] = max(dp[i], dp[j] + 1)