两个不同排列的最长公共子序列

最新推荐文章于 2024-08-31 09:35:05 发布

原创最新推荐文章于 2024-08-31 09:35:05 发布 · 656 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#算法 #c++

动态规划专栏收录该内容

30 篇文章

订阅专栏

本文介绍了一种求解两个排列的最长公共子序列问题的方法，包括朴素线性动态规划及优化后的最长上升子序列算法。通过映射序列，将问题转化为求解一个序列的最长上升子序列。

题目描述

给出 $1,2,\ldots,n$ 的两个排列 $P_1$ 和 $P_2$ ，求它们的最长公共子序列。

输入格式

第一行是一个数 $n$ 。

接下来两行，每行为 $n$ 个数，为自然数 $1,2,\ldots,n$ 的一个排列。

输出格式

一个数，即最长公共子序列的长度。

样例 #1

样例输入 #1

5 
3 2 1 4 5
1 2 3 4 5

样例输出 #1

提示

对于 $50\%$ 的数据， $\le 10^3$ ；
对于 $100\%$ 的数据， $\le 10^5$ 。

朴素线性动态规划

状态表示： $f [i] [j]$ 表示从序列 $A$ 的前 $i$ 个元素与序列 $B$ 的前 $j$ 个元素中挑选出的公共子序列的最大长度
状态转移：
- 如果 $A [i] = B [j]$ ， $f [i] [j] = f [i - 1] [j - 1] + 1$
- 否则 $A [i]! = B [j]$ ， $f[i][j] = max\{f[i - 1][j],f[i][j - 1]\}$
初始状态： $f [0] [0] = 0$

时间复杂度

需要枚举 $i 、 j$ 计算状态，因此时间复杂度为 $O(n^2)$ 。

代码实现

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e3 + 10;
int a[N], b[N];
int f[N][N];
int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++) scanf("%d", &a[i]);
    for(int i = 1; i <= n; i ++) scanf("%d", &b[i]);
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= n; j ++)
        {
            if(a[i] == b[j]) f[i][j] = f[i - 1][j - 1] + 1;
            else f[i][j] = max(f[i - 1][j], f[i][j - 1]);
        }
    cout << f[n][n] << endl;
    return 0;
}

最长上升子序列

题目中给出的是 $1,2,\ldots,n$ 的两个排列 $P_1$ 和 $P_2$ ，也就是说这两个序列中元素是一样的，不一样的是元素的出现顺序。如果将题目给出的测试样例按照字母顺序映射为两个新序列 $A$ 和 $B$ ，那么：
$P_1 = 3 2 1 4 5 \rightarrow A = abcde$
$P_2 = 1 2 3 4 5 \rightarrow B = cbade$
那么可以得到一个性质， $B$ 的一个上升子序列即两个序列的公共子序列。因此该问题可以转换为求映射后B序列的上升子序列的最大长度。

时间复杂度

由于最长上升子序列的问题可以使用贪心 + 二分的方式进行优化，因此本题时间复杂度可以优化到 $O (n l o g n)$ ，详情可以参考我的这篇文章：NOIP1999提高组T1：导弹拦截

代码实现

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10;
int map[N],a[N], b[N], q[N];
int main()
{
    int n, x, len = 0;
    cin >> n;
    for(int i = 1; i <= n; i ++) 
    {
        cin >> a[i];
        map[a[i]] = i; //将a[i]进行映射
    }
    for(int i = 1; i <= n; i ++) cin >> b[i];
    q[len] = -1e9;
    for(int i = 1; i <= n; i ++)
    {
    	//求映射后b序列的最长上升子序列
        if(q[len] < map[b[i]]) q[++ len] = map[b[i]];
        else
        {
            int L = 0, R = len, mid;
            while(L < R)
            {
                mid = (L + R) / 2;
                if(q[mid] >= map[b[i]]) R = mid;
                else L = mid + 1;
            }
            q[L] = min(q[L], map[b[i]]); 
        }
    }
    cout << len << endl;
    return 0;
}