LIS,LCS,一道LIS题

最新推荐文章于 2021-08-18 17:04:09 发布

维克多_y

最新推荐文章于 2021-08-18 17:04:09 发布

阅读量298

点赞数

分类专栏： acm竞赛文章标签： LIS HDU 5532 LCS

本文链接：https://blog.csdn.net/qq_33216593/article/details/52541066

版权

acm竞赛专栏收录该内容

7 篇文章 0 订阅

订阅专栏

LCS，最长公共子序列，根据算导的推论，可以得到如下公式：

c[ i ][ j ] = 0 (i = 0或j = 0)

c[ i ][ j ] = c[ i-1 ] [ j-1 ] + 1 (i,j>0且xi = yj)

c[ i ][ j ] = max (c [ i ][ j-1 ],c [ i-1 ][ j ]) (i ， j>0且 xi≠yj )

自己根据算导敲了下：（感觉时间复杂度还是不够高）

#include<iostream>
#include<string.h>
#define MAX 20000
using namespace std;
int c[MAX][MAX];
int x[MAX];
int y[MAX];
int M,N;
void LCS(int m,int n)
{
    for(int i=0;i<=m;i++)
    {
        c[i][0]=0;
    }
    for(int i=0;i<=n;i++)
    {
        c[0][i]=0;
    }
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(x[i]==y[j])
            {
                c[i][j]=c[i-1][j-1]+1;
            }
            else if(c[i-1][j]>=c[i][j-1])
            {
                c[i][j]=c[i-1][j];
            }
            else
            {
                c[i][j]=c[i][j-1];
            }
        }
    }
}
int main()
{
    cin>>M>>N;
    int d[100000];
    int ans=0;
    for(int i=1;i<=M;i++)
    {
        cin>>x[i];
    }
    for(int i=1;i<=N;i++)
    {
        cin>>y[i];
    }
    memset(c,0,sizeof(c));
    LCS(M,N);
    while(1)
    {
        if(M==0||N==0)break;
        if(c[M-1][N]==c[M][N])
        {
            M-=1;
        }
        else if(c[M][N-1]==c[M][N])
        {
            N-=1;
        }
        else
        {
            d[ans++]=x[M];
            M-=1;
            N-=1;
        }

    }
    for(int i=ans-1;i>=0;i--)
    {
        cout<<d[i]<<" ";
    }
    cout<<endl;
}
/*
7 6
1 2 3 2 4 1 2
2 4 3 1 2 1
*/

LIS

最长上升子序列，没有写N*N的算法，直接上N*logn;

最长上升子序列的O(n＊logn)算法分析如下:

先回顾经典的O(n＾2)的动态规划算法，设a[t]表示序列中的第t个数，dp[t]表示从1到t这一段中以t结尾的最长上升子序列的长度，初始时设dp [t] = 0(t = 1, 2, ..., len(a))。则有动态规划方程：dp[t] = max{1, dp[j] + 1} (j = 1, 2, ..., t - 1, 且a[j] < a[t])。

现在，我们仔细考虑计算dp[t]时的情况。假设有两个元素a[x]和a[y]，满足

(1)x < y < t

(2)a[x] < a[y] < a[t]

(3)dp[x] = dp[y]

此时，选择dp[x]和选择dp[y]都可以得到同样的dp[t]值，那么，在最长上升子序列的这个位置中，应该选择a[x]还是应该选择a[y]呢？

很明显，选择a[x]比选择a[y]要好。因为由于条件(2)，在a[x+1] ... a[t-1]这一段中，如果存在a[z]，a[x] < a[z] < a[y]，则与选择a[y]相比，将会得到更长的上升子序列。

再根据条件(3)，我们会得到一个启示：根据dp[]的值进行分类。对于dp[]的每一个取值k，我们只需要保留满足dp[t] = k的所有a[t]中的最小值。设D[k]记录这个值，即D[k] = min{a[t]} (dp[t] = k)。

注意到D[]的两个特点：

(1)　D[k]的值是在整个计算过程中是单调不上升的。

(2)　D[]的值是有序的，即D[1] < D[2] < D[3] < ... < D[n]。

利用D[]，我们可以得到另外一种计算最长上升子序列长度的方法。设当前已经求出的最长上升子序列长度为len。先判断a[t]与D[len]。若a [t] > D[len]，则将a[t]接在D[len]后将得到一个更长的上升子序列，len = len + 1， D[len] = a [t]；否则，在D[1]..D[len]中，找到最大的j，满足D[j] < a[t]。令k = j + 1，则有a [t] <= D[k]，将a[t]接在D[j]后将得到一个更长的上升子序列，更新D[k] = a[t]。最后，len即为所要求的最长上升子序列的长度。

在上述算法中，若使用朴素的顺序查找在D[1]..D[len]查找，由于共有O(n)个元素需要计算，每次计算时的复杂度是O(n)，则整个算法的时间复杂度为O(n^2)，与原来的算法相比没有任何进步。但是由于D[]的特点(2)，我们在D[]中查找时，可以使用二分查找高效地完成，则整个算法的时间复杂度下降为O(nlogn)，有了非常显著的提高。需要注意的是，D[]在算法结束后记录的并不是一个符合题意的最长上升子序列！

这里直接采用一道用到LIS的题说明：

HDU 5532

题目大意是，问去掉一个数，剩下的数是否是非递增或非递减序列

样例输入为

3
3
2 1 7
3
3 2 1
5
3 1 4 1 5

样例输出是

YES
YES
NO

直接用LIS正着和倒着跑一边LIS，看长度是否有>=总长度-1的序列，有就输出YES，没有输出NO

可是跑了却只能过样例，结果还是wrong，不知是否有什么bug，敢为有人可否告诉我？

这是代码：

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
using namespace std;
const int N = 100010;
int a[N],f[N],d[N],b[N];
int r;
int bsearch(const int *f ,int size ,const int &a)
{
    int l=0;r=size-1;
    while(l<=r){
        int mid=(l+r)/2;
        if(a>f[mid-1]&&a<=f[mid])return mid;
        else if(a<f[mid])r=mid-1;
        else l=mid+1;
    }
}
int LIS(const int *a,const int &n)
{
    int i,j,size=1;
    f[0]=a[0];d[0]=1;
    for(i=1;i<n;++i)
    {
        if(a[i]<f[0])j=0;
        else if(a[i]>=f[size-1])j=size++;
        else j=bsearch(f,size,a[i]);
        f[j]=a[i];
        d[i]=j+1;
    }
    return size;
}
int main()
{
    int i,n;
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        memset(a,0,sizeof(a));
        for(int i=0; i<n; i++)
        {
            scanf("%d",&a[i]);
        }
//        for(int i=0;i<n;i++)
//        {
//            cout<<a[i]<<" ";
//        }
//        cout<<endl;
//        for(int i=0;i<n;i++)
//        {
//            cout<<b[i]<<" ";
//        }
//        cout<<endl;
        //cout<<strcmp(a,b)<<endl;
        cout<<LIS(a,n)<<endl;
        int r=LIS(a,n);
        reverse(a,a+n);
        int t=LIS(a,n);
        if(r>=n-1||t>=n-1)
        {
            printf("YES\n");
        }
        else
            printf("NO\n");
    }
    return 0;
}

后来找了题解，也有用LIS的，不过有点晦涩难懂，却可以A过，这是别人的代码：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;
const int maxn = 1e5 + 5;

struct Stack {
    int n, s[maxn];
    void init() { n = 0; }
    int find (int x) { return upper_bound(s, s + n, x) - s; }
    void insert(int p, int x) {
        s[p] = x;
        n = max(n, p + 1);
    }
}S;

int N, A[maxn], dp[maxn];

bool judge () {
    S.init();
    int ans = 0;
    for (int i = 1; i <= N; i++) {
        dp[i] = S.find(A[i]);
        S.insert(dp[i], A[i]);
        ans = max(ans, dp[i] + 1);
    }
    return ans >= N-1;
}

int main () {
  printf("%d",maxn);
    int cas;
    scanf("%d", &cas);
    while (cas--) {
        scanf("%d", &N);
        for (int i = 1; i <= N; i++) scanf("%d", &A[i]);

        bool flag = judge();
        reverse(A + 1, A + N + 1);
        flag |= judge();
        printf("%s\n", flag ? "YES" : "NO");
    }
    return 0;
}

自己也模拟了一遍，也是过不了，就不粘了。。。/ganga

维克多_y

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LIS,LCS,一道LIS题

LCS，最长公共子序列，根据算导的推论，可以得到如下公式：c[ i ][ j ] = 0 (i = 0或j = 0)c[ i ][ j ] = c[ i-1 ] [ j-1 ] + 1 (i,j>0且xi = yj)c[ i ][ j ] = max (c [ i ][ j-1 ],c [ i-1 ][ j ]) (i ， j>0且 xi≠yj )自己根据算导敲了下：（感觉时间
复制链接

扫一扫