zoukankan      html  css  js  c++  java
  • HDU 1423 Greatest Common Increasing Subsequence(最长公共上升LCIS)

    HDU 1423 Greatest Common Increasing Subsequence(最长公共上升LCIS)

    http://acm.hdu.edu.cn/showproblem.php?pid=1423

    题意:

           给你两个数字组成的串a和b,要你求出它们的最长公共严格递增子序列的长度(LCIS).

    分析:

           首先我们令f[i][j]==x表示是a串的前i个字符与b串的前j个字符构成的且以b[j]结尾的LCIS长度.

           当a[i]!=b[j]时:

           f[i][j]=f[i-1][j]

           当a[i]==b[j]时:

           f[i][j]=max(f[i-1][k])+1. 当中 k<j且b[k]<b[j].

           假设我们按上述递推公式依次枚举i, j, k 的话,那么时间复杂度就是O(n*m^2)了.

           事实上我们仅仅要枚举i, j. 然后我们记录当前的最大f[i-1][k]值就可以(要满足k<jb[k]<b[j]). 程序实现用到了一个技巧, 即枚举(i, j)情况时如果a[i]的值与b[j+1]的值是相等的. 那么仅仅要b[j]<a[i]的话, 我们直接更新max=f[i-1][j]就可以. 如果下一轮a[i]==b[j+1], 那么上一轮max保存的值f[i-1][j] 能够肯定j<j+1 且b[j]<a[i]==b[j+1]. (b[j]变成b[k]也是一样)

           怎样输出一个LCIS串呢?

          我们首先找到使得f[n][id]取最大值的id. 然后它肯定是由f[n-1][k](k<idb[k]<b[id]) 构成的. 所以我们仅仅须要往前找到那个f[n-1][k]==f[n][id]-1 且 b[k]<b[id]的值逆序输出就可以. 事实上动态规划的全部输出方案的问题都能够这么输出.

           假设想输出字典序最小的LCIS串呢?

    我们仅仅须要将原来的两个序列逆转,然后找出最长公共递减子序列. 然后从第一个LCDS的字符開始找尽可能字典序小的字符就可以. 事实上思想大致都是一样的.

    AC代码:

    </pre><pre name="code" class="cpp">#include<cstdio>
    #include<cstring>
    #include<algorithm>
    using namespace std;
    const int maxn=500+5;
    
    int n;//a串长
    int m;//b串长
    int a[maxn];//a串
    int b[maxn];//b串
    int f[maxn][maxn];
    
    int main()
    {
        int T;
        scanf("%d",&T);
        while(T--)
        {
            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(f,0,sizeof(f));
            for(int i=1;i<=n;i++)
            {
                int max=0;//当前f[i-1][k]最大值且 k<j&&b[k]<b[j]
                int flag=-1;
                for(int j=1;j<=m;j++)
                {
                    f[i][j]=f[i-1][j];
                    if(a[i]>b[j] && max<f[i-1][j])
                    {
                        max=f[i-1][j];
                        flag=j;
                    }
                    if(a[i]==b[j])
                    {
                        f[i][j]=max+1;
                    }
                }
            }
    
            int max_val=0;
            int id=-1;
            for(int i=1;i<=m;i++)
            {
                if(max_val<f[n][i])
                {
                    max_val=f[n][i];
                    id=i;
                }
            }
    
            printf("%d
    ",max_val);
            if(T) printf("
    ");
    
            //逆序输出一个LCIS串
            /*
            int i=n;
            while(id!=-1 && f[i][id]>=1)
            {
                printf("%d ",b[id]);
                int tmp=f[i][id];
                int tmp_v=b[id];
                //往前找到合法的f[i-1][k]
                while(id!=0)
                {
                    id--;
                    if(f[i-1][id]==tmp-1 && b[id]<tmp_v)
                        break;
                }
                i--;
            }
            printf("
    ");
            */
    
        }
        return 0;
    }
    



  • 相关阅读:
    南大《软件分析》课程笔记——Intermediate Representation
    leetcode刷题
    shiro550反序列化分析
    南大《软件分析》课程笔记——第一课
    再见2020
    S2-002漏洞分析
    编码&解码工具
    正码、反码和补码
    Java数据结构(二)
    Java数据集合
  • 原文地址:https://www.cnblogs.com/blfshiye/p/5150957.html
Copyright © 2011-2022 走看看