uva10635 - Prince and Princess

最新推荐文章于 2020-07-08 11:56:16 发布

原创最新推荐文章于 2020-07-08 11:56:16 发布 · 347 阅读

1 ·

CC 4.0 BY-SA版权

训练之南第一章同时被 3 个专栏收录

38 篇文章

订阅专栏

动态规划

26 篇文章

订阅专栏

动态规划 - 子序列

9 篇文章

订阅专栏

本文介绍了一种优化的最长公共子序列算法，通过将其中一个序列转换为单调递增序列来提高效率。详细阐述了算法的实现过程，并通过实例展示了应用方法。

题意：
给你两个序列，求最长公共子序列。

思路：
直接LCS会超时,所以将其转为LIS，即将其中一个序列转为单调递增的序列，再遍历，不断更新直至最长。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 90000;

int n, m, k, ha[N], a[N], dp[N];

int main() {
    int cas, index = 0;
    scanf("%d", &cas);
    while (cas--) {
        memset(ha, 0, sizeof(ha));
        memset(a, 0, sizeof(a));
        memset(dp, 0, sizeof(dp));
        scanf("%d%d%d", &n, &m, &k);
        m++; k++;
        int i,cur;
        for (i = 1; i <= m; i++) {
            scanf("%d", &cur);
            ha[cur] = i;
        }
        for (i = 1; i <= k; i++) 
            scanf("%d", &a[i]);

        int cnt = 0, j;
        for (i = 1; i <= k; i++) {
            if (!ha[a[i]])//不存在
                continue;
            int flag = 1;
            for (j = 0; j < cnt; j++) {
                if (ha[a[i]] < ha[dp[j]]) {
                    dp[j] = a[i];
                    flag = 0;
                    break;
                }
            }
            if (flag)
                dp[cnt++] = a[i];

        }
        printf("Case %d: %d\n", ++index, cnt);
    }
    return 0;
}