学习笔记：子序列模型

最新推荐文章于 2024-07-22 09:38:37 发布

心情想要飞

最新推荐文章于 2024-07-22 09:38:37 发布

阅读量217

点赞数 2

分类专栏：学习笔记（提高篇）文章标签：动态规划 c++ 最长上升子序列最长公共子序列 dp

本文链接：https://blog.csdn.net/weixin_44043668/article/details/108832805

版权

学习笔记（提高篇）专栏收录该内容

14 篇文章 2 订阅

订阅专栏

最长上升/不上升/下降/不下降子序列

概念

上升序列，指一个序列中每一个数都是递增的。最长上升子序列，就是一个序列中找出最长的一个每一个数都递增的子序列，其余的同理。比如： $129314223192173$ 一个上升子序列： $123173$ 最长上升子序列： $12192173$ 这个也是： $9314273$ 所以，最长上升子序列不是唯一的。这个最长上升子序列的长度是 $4$ 。特殊的，空序列也是上升/不上升/下降/不下降子序列。

方法

这里以上升子序列为例。可以思考，当一个序列结束的一个数小于该数，则该数可以加在这个序列上。于是，方案就出来了：设 $f_i$ 为以 $i$ 结束的最长上升子序列，那么 $f_i=\max(f_j,j<i,a[j]<a[i])+1$ 。其余的同理。

例题

AcWing 1017

这个题可以发现，如果从左到右就是一个最长上升子序列问题。那么从右到左呢？因为这个题数据不大，可以从右往左再做一遍。当然，也不难发现，如果从右往左是上升子序列，那么从左往右看就是下降子序列。于是，本题就能解决了。

#include<bits/stdc++.h>
using namespace std;
const int NN=104;
int a[NN],f1[NN],f2[NN];
int main()
{
	int k;
	scanf("%d",&k);
	while(k--)
	{
		int n,ans=0;
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
			f1[i]=f2[i]=1;
			for(int j=1;j<=i-1;j++)
			{
				if(a[j]>a[i])
					f1[i]=max(f1[i],f1[j]+1);
				if(a[j]<a[i])
					f2[i]=max(f2[i],f2[j]+1);
			}
			ans=max(ans,max(f1[i],f2[i]));
		}
		printf("%d\n",ans);
	}
	return 0;
}

这个题发现不太对，居然是先上升后下降的样子。但是我们可以把它拆成两个部分：上升部分和下降部分。所以我们可以枚举一个分界点，前面上升后面下降。这样就是以 $i$ 结束的最长上升和下降子序列问题，直接相加就行了。注意，中间点 $i$ 被计算了两次，要减一。但是上一题处理下降子序列的简便方式在这里并不适用，因为那个存的是 $i$ 开始的最长下降子序列，这个题是要求 $i$ 结束的，所以只能从右往左再算一遍。

#include<bits/stdc++.h>
using namespace std;
const int NN=1004;
int a[NN],f1[NN],f2[NN];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	int ans=0;
	for(int i=1;i<=n;i++)
	{
		f1[i]=1;
		for(int j=1;j<=i-1;j++)
			if(a[j]<a[i])
				f1[i]=max(f1[i],f1[j]+1);
	}
	for(int i=n;i>=1;i--)
	{
		f2[i]=1;
		for(int j=i+1;j<=n;j++)
			if(a[j]<a[i])
				f2[i]=max(f2[i],f2[j]+1);
	}
	for(int i=1;i<=n;i++)
		ans=max(f1[i]+f2[i]-1,ans);
	printf("%d\n",ans);
	return 0;
}

AcWing 482

这个题和上一题没有任何区别。出队的越少留下的就越多，用 $n$ 减去最长的一个上升又下降的子序列即可。

#include<bits/stdc++.h>
using namespace std;
const int NN=1004;
int a[NN],f1[NN],f2[NN];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	int ans=0;
	for(int i=1;i<=n;i++)
	{
		f1[i]=1;
		for(int j=1;j<=i-1;j++)
			if(a[j]<a[i])
				f1[i]=max(f1[i],f1[j]+1);
	}
	for(int i=n;i>=1;i--)
	{
		f2[i]=1;
		for(int j=i+1;j<=n;j++)
			if(a[j]<a[i])
				f2[i]=max(f2[i],f2[j]+1);
	}
	for(int i=1;i<=n;i++)
		ans=max(f1[i]+f2[i]-1,ans);
	printf("%d\n",n-ans);
	return 0;
}

AcWing 1012

这个题目感觉和最长上升子序列没有关系，但是我们发现，两个相交当且仅当 $u_i>u_j$ 且 $v_i<v_j$ 或者符号反着。所以，我们给 $u$ 从小到大排序，则选出的 $v$ 一定是上升的。所以，就变成了求由 $v$ 组成的最长上升子序列问题。

#include<bits/stdc++.h>
using namespace std;
const int NN=5004;
pair<int,int>a[NN];
int f[NN];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d%d",&a[i].first,&a[i].second);
	sort(a+1,a+1+n);
    int ans=0;
	for(int i=1;i<=n;i++)
	{
		f[i]=1;
		for(int j=1;j<i;j++)
			if(a[j].second<a[i].second)
			    f[i]=max(f[i],f[j]+1);
	    ans=max(ans,f[i]);
	}
	printf("%d",ans);
	return 0;
}

AcWing 1016

这个题从原来的求最长上升子序列变成了求和最大的上升子序列。之前新加一个数 $a_i$ 子序列的长度长度加 $1$ ，现在和却增加了 $a_i$ ，所以状态转移方程就变成了 $max(f_j,a_j<a_i,j<i)+a_i$ ，只用自己（边界条件）也是 $f_i=a_i$ 。

#include<bits/stdc++.h>
using namespace std;
const int NN=1004;
int a[NN],f[NN];
int main()
{
	int n,ans=0;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
	    scanf("%d",&a[i]);
		f[i]=a[i];
		for(int j=1;j<i;j++)
			if(a[j]<a[i])
			    f[i]=max(f[i],f[j]+a[i]);
		ans=max(ans,f[i]);
	}
	printf("%d",ans);
	return 0;
}

AcWing 1010

这个题第一问就是一个典型的最长不上升子序列，直接 $d p$ 解决。那么第二问呢？可以记录每一个防御系统最后一次处理的高度，如果没有能处理新的的防御系统那么就新加一个。但是如果有选用哪个呢？选最小的，因为其他的还可以处理更高的，所以就用一个"最差的"就行了。

#include<bits/stdc++.h>
using namespace std;
const int NN=1004;
int a[NN],f[NN],h[NN];
int main()
{
	int i=0,ans=0,num=0;
	h[0]=1e9;
	while(scanf("%d",&a[++i])!=EOF)
	{
	    f[i]=1;
		for(int j=1;j<i;j++)
			if(a[j]>=a[i])
				f[i]=max(f[i],f[j]+1);
		ans=max(ans,f[i]);
		int k=0;
		for(int j=1;j<=num;j++)
			if(h[j]>=a[i]&&h[j]<h[k])
				k=j;
		if(!k)
		{
			num++;
			k=num;
		}
		h[k]=a[i];
	}
	printf("%d\n%d",ans,num);
	return 0;
}

AcWing 187

这个题目可以考虑上一题那道题的贪心算法。但是这个题目可以选择上升或者下降，贪心无法在新加一个时确定是上升还是下降。于是我们再分析，发现题目中 $n$ 很小，不难想到可以暴搜。每次两种决策，在下降的选一个或者新加，在上升的选一个或者新加。这样分成了两种，就可以分别贪心了。注意，如果当前用的个数大于答案就可以退出了，因为最小的一定会是这个方案。用 $u$ 表示上升的序列的个数， $d$ 表示下降， $t$ 表示处理第几个。

#include<bits/stdc++.h>
using namespace std;
const int NN=54;
int a[NN],up[NN],down[NN],n,ans;
void dfs(int u,int d,int t)
{
    if(u+d>=ans)
        return;
    if(t==n)
    {
        ans=u+d;
        return;
    }
    int k=u+1;
    for(int i=1;i<=u;i++)
        if(up[i]<a[t])
        {
            k=i;
            break;
        }
    int temp=up[k];
    up[k]=a[t];
    dfs(max(u,k),d,t+1);
    up[k]=temp;
    k=d+1;
    for(int i=1;i<=d;i++)
        if(down[i]>a[t])
        {
            k=i;
            break;
        }
    temp=down[k];
    down[k]=a[t];
    dfs(u,max(d,k),t+1);
    down[k]=temp;
}
int main()
{
    while(scanf("%d",&n)!=EOF&&n)
    {
        ans=1e9;
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        dfs(0,0,0);
        printf("%d\n",ans);
    }
    return 0;
}

最长公共子序列

概念

两个序列，分别选出一个子序列，要求这两个子序列相等，这就是公共子序列。最长公共子序列就是最长的一个。比如： $16245837$ $26358714$ 一个公共子序列： $63 ７$ 一个最长公共子序列： $2587$ 这个也是： $6587$ 可见，最长公共子序列也不是唯一的。

方法

首先，拿到这个题很容易把这个状态表示出来： $f_{i,j}$ 表示 $s1_{1...i}$ 和 $s2_{1...j}$ 的最长公共子序列长度。于是，我们就会出现几种情况：

都不用： $f_{i,j}=f_{i-1,j-1}$
不用 $s1_i$ ： $f_{i,j}=f_{i-1,j}$
不用 $s2_j$ ： $f_{i,j}=f_{i,j-1}$
都用：这种情况只有两个相等才可以。所以，就是都不用的长度加一。 $f_{i,j}=f_{i-1,j-1}+1$

然后我们根据这个来写代码是能得到正确答案的。但是仔细思考会发现一个事：有一些状态之间是包含了的。比如第一条，其实就被第二条和第三条包含了。因为之前 $f_{i-1,j}$ 在之前用转移三，则迭代成了 $f_{i-1,j-1}$ ，第三条同理。所以，我们可以去掉第一条。那么再考虑，发现第四条肯定是最优的，因为 $f_{i-1,j}$ 可以从 $f_{i-2,j}$ 、 $f_{i-1,j-1}$ 以及 $f_{i-2,j-1}+1$ 迭代，其中第二个绝对不可能比转移四优，第三个其实少一个字符参加计算肯定也不会更有。第一个只要一出现 $j - 1$ 就一定不是最优，那么只能一直 $f_{i-k,j}$ 地迭代，所以最后会迭代到 $f_{0,j}$ ，为 $0$ ，肯定不是最优。所以，当两个相等直接计算第四个状态转移方程即可。

例题

AcWing 272

这个居然还加了一个上升的条件，那么怎么办呢？我们可以思考一下，这不就是最长上升子序列和最长公共子序列的结合体吗？所以我们可以结合一下，首先，最长上升子序列的状态是 $f_i$ 表示以 $i$ 结束的最长上升子序列，最长公共子序列的状态是 $f_{i,j}$ 表示 $s1_{1...i}$ 和 $s2_{1...j}$ 的最长公共子序列。所以，我们可以设一个状态 $f_{i,j}$ 表示用 $s1_{1...i}$ 且以 $s2_j$ 结束的一个最长公共上升子序列。因为公共子序列是一样的，所以只用一个表示以某个结束即可。思考状态转移， $f_{i,j}$ 首先可以转移成不用 $s2_i$ ，则 $f_{i,j}=f_{i-1,j}$ ，但是第二个要求以 $s2_j$ 结束，所以不能不用 $s2_j$ 。于是就思考，在两个相等的时候怎么转移。其实就是这个公共子序列上一个是什么，然后再补一个新加入的我们。

只有 $s2_j$ ，长度为 $1$
上一个是 $s2_1$ ， $f_{i,j}=f_{i-1,1}+1$ ，要求 $s2_1<s2_j$
以此类推，直到 $s2_{j-1}$

所以，就可以三层循环，计算每一个 $f_{i,j}$ 。但是这个题 $n$ 最大是 $3000$ ，时间复杂度根本受不了。不难发现如果内层循环计算 $s 2$ 和枚举每一个 $j$ ，所以可以边循环边统计。因为 $s 2$ 放在内层循环，则数是实时变化的，但都要求等于 $s1_i$ ，所以改成和 $s1_i$ 比较是否上升即可。最后依次计算，如果两个相等就是可以进行第二条状态转移的，现在直接和统计的 $\max$ 比较即可。注意要先转移完了再更新 $\max$ 。

#include<bits/stdc++.h>
using namespace std;
const int NN=3004;
int a[NN],b[NN],f[NN][NN];
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++)
    {
        int maxx=1;
        for(int j=1;j<=n;j++)
        {
            f[i][j]=f[i-1][j];
            if(a[i]==b[j])
                f[i][j]=max(f[i][j],maxx);
            if(a[i]>b[j])
                maxx=max(maxx,f[i-1][j]+1);
        }
    }
    int res=0;
    for(int i=1;i<=n;i++)
        res=max(res,f[n][i]);
    printf("%d",res);
    return 0;
}

心情想要飞

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习笔记：子序列模型

上讲习题：AcWing 275法一：和上一题法一基本一模一样。本题不让走到同一点，那么就判断是否是同一点，是同一点就不计算。如果是从同一点过来的，那么那个点之前就没有更新，所以是零，最大值绝对不是它，所以也不会用它更新。因为两条路都会到最后一个点，所以最后一个点不会更新，直接输出差一步到达终点的两条路径即可。注意，这样的两条路径只有一个：从左边和上边来的两条路径。#include<bits/stdc++.h>using namespace std;const int NN=54;i
复制链接

扫一扫

专栏目录