HDU 1423 Greatest Common Increasing Subsequence （LCIS）

最新推荐文章于 2020-04-02 23:23:23 发布

原创最新推荐文章于 2020-04-02 23:23:23 发布 · 187 阅读

0 ·

CC 4.0 BY-SA版权

基础线性dp（背包，序列问题) 专栏收录该内容

22 篇文章

订阅专栏

F - Greatest Common Increasing Subsequence

HDU - 1423

队内赛看到这个题，当时思路是先求出最长公共子序列，然后再求出其最长上升子序列，然而由于前者无法记录，这道题算是浪费了好长时间，后来从网上搜也没搜到应该怎么记录，再后来就知道这原来是一道裸的LCIS，知识面还是太窄啊

看这个博客讲的不错：LCIS

这种题有O（n ^ 3）和 O(n ^ 2）两种方法，后者是对前者的优化

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int a[1005], b[1005];
int dp[1005][1005];
int main()
{
    int t;
    scanf("%d",&t);
    while(t --)
    {
        int m, n;
        scanf("%d",&n);
        for(int i = 1; i <= n; i ++)
            scanf("%d",&a[i]);
        scanf("%d",&m);
        for(int i = 1; i <= m; i ++)
            scanf("%d",&b[i]);
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= n; i ++)
            for(int j = 1; j <= m; j ++)
        {
            if(a[i] != b[j])
            dp[i][j] = dp[i - 1][j];
            else
            {
                int maxy = 0;
                for(int k = 1; k < j; k ++)
                    if(b[j] > b[k])
                    maxy = max(maxy, dp[i - 1][k]);
                dp[i][j] = maxy + 1;
            }
        }
        int ans = 0;
        for(int i = 1; i <= m; i ++)
            ans = max(ans, dp[n][i]);
        printf("%d\n",ans);
        if(t != 0)printf("\n");
    }
    return 0;
}

然后是优化后的

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int a[1005], b[1005];
int dp[1005][1005];
int main()
{
    int t;
    scanf("%d",&t);
    while(t --)
    {
        int m, n;
        scanf("%d",&n);
        for(int i = 1; i <= n; i ++)
            scanf("%d",&a[i]);
        scanf("%d",&m);
        for(int i = 1; i <= m; i ++)
            scanf("%d",&b[i]);
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= n; i ++)
        {
            int maxy = 0;
            for(int j = 1; j <= m; j ++)
            {
                if(a[i] != b[j])dp[i][j] = dp[i - 1][j];
                if(a[i] > b[j])maxy = max(dp[i - 1][j], maxy);
                if(a[i] == b[j])dp[i][j] = maxy + 1;
            }
        }
        int ans = 0;
        for(int i = 1; i <= m; i ++)
            ans = max(ans, dp[n][i]);
        printf("%d\n",ans);
        if(t != 0)printf("\n");
    }
    return 0;
}

显然同理，只要把a[i] > b[j]改为a[i] < b[j]，就能实现最长下降子序列