最长上升子序列模型+

最新推荐文章于 2024-11-16 21:36:47 发布
最新推荐文章于 2024-11-16 21:36:47 发布
阅读量162 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52694528/article/details/120923408
版权

1017. 怪盗基德的滑翔翼
思路：f[i]来表示以a[i]为结尾的最长上升子序列。它有两个方向可以选择，当它往左边跳时，从左向右看跳过的那段序列要是单调递增的，就是在寻找最长公共子序列；当它往右边跳时，跳过的那段序列要是单调递减的，就是反过来从后往前找最长上升子序列。

include<iostream>
using namespace std;
const int N=110;
int a[N],f[N];
int main()
{
	int k,n;
	cin>>k;
	while(k--)
	{
		cin>>n;
		int res=0;
		for(int i=1;i<=n;i++)
			cin>>a[i];	
		//相当于往左边跳
		for(int i=1;i<=n;i++)
		{
			f[i]=1;
			for(int j=1;j<i;j++)
			{
				if(a[i]>a[j])
				{
					f[i]=max(f[i],f[j]+1);
				}
			}
			res=max(res,f[i]);
		}
		//相当于往右边跳
		for(int i=n;i>0;i--)
		{
			f[i]=1;
			for(int j=n;j>i;j--)
			{
				if(a[i]>a[j])
					f[i]=max(f[i],f[j]+1);
			}
			res=max(res,f[i]);
		}
		cout<<res<<endl;
	}
	return 0;
}

1014. 登山
思路：爬山的过程中，一旦往低处走了，就只能往更低处走，所以走的路线一定满足严格单调递增后单调递减的情况。所以以a[i]为分界点，分别算出以a[i]为结尾的最长上升子序列长度f[i]和逆向看以a[i]为结尾的最长上升子序列g[i]，最后在把两个对应的相加起来比较求出最大值。

#include<iostream>
using namespace std;
const int N=1010;
int a[N],f[N],g[N];
int main()
{
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	int res=0;
	for(int i=1;i<=n;i++)//递增的一块
	{
		f[i]=1;
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j])
				f[i]=max(f[i],f[j]+1);
		}
	}
	for(int i=n;i>0;i--)//递减
	{
		g[i]=1;
		for(int j=n;j>i;j--)
			if(a[i]>a[j])
				g[i]=max(g[i],g[j]+1);
	}
	for(int i=1;i<=n;i++)
		res=max(res,f[i]+g[i]-1);//a[i]这个点在f[i],g[i]里都包含了
	printf("%d\n",res);
}

482. 合唱队形
思路：与登山的思路是一样的，以每个点a[i]为分割点，求出它的左右两侧递增f[i]和递减g[i]的最长长度，最后把所有f[i]和g[i]一一相加，选出最大的一个，再用总人数减去它。这里与登山不同的是求最大和的时候并不是把同一点的f[i],g[i]加起来取最大值，而是让所有点的f[i],g[i]一一相加选最大的（它有多段分开的上升和下降子序列）。因为他是要取掉连续的一段，所以中间是会有断开的时候。

#include<iostream>
using namespace std;
const int N=110;
int a[N],f[N],g[N];
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++)
	{
		f[i]=1;//记得初始化
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j])
				f[i]=max(f[i],f[j]+1);
		}
	}
	for(int i=n;i>0;i--)
	{
	    g[i]=1;//记得初始化
		for(int j=n;j>i;j--)
		{
			if(a[i]>a[j])
				g[i]=max(g[i],g[j]+1);
		}
	}
	int res=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=i;j<=n;j++)
		{
			if(i==j)
				res=max(res,f[i]+g[j]-1);
			else
				res=max(res,f[i]+g[j]);
		}
	}
	printf("%d\n",n-res);
	return 0;
}

1012. 友好城市
思路：先对河岸的一边排序，再在另一边找最长上升子序列模型，即岸的另一边的坐标要在a[i]之前这一段是单调递增的，这样子保证了在岸的两边到a[i]这一段都是单调递增的，就不会有交叉的情况出现。

#include<iostream>
#include<algorithm>
using namespace std;
const int N=5010;
int f[N];
typedef pair<int,int> PII;
PII a[N];
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,a+n+1);
	int res=0;
	for(int i=1;i<=n;i++)
	{
		f[i]=1;
		for(int j=1;j<=i;j++)
		{
			if(a[i].second>a[j].second)
			{
				f[i]=max(f[i],f[j]+1);
			}
		}
		res=max(res,f[i]);
	}
	printf("%d\n",res);
	return 0;
}

1016. 最大上升子序列和

思路：把求最长上升子序列长度的长度改为每个数被选上的值。

#include<iostream>
using namespace std;
const int N=1010;
int f[N],a[N];
int main()
{
	int n;
	scanf("%d",&n);
	int res=0;
	for(int i=1;i<=n;i++)
	{
		f[i]=a[i];
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j])
			{
				f[i]=max(f[i],f[j]+a[i]);
			}
		}
		res=max(res,f[i]);
	}
	printf("%d\n",res);
	return 0;
}

1010. 拦截导弹
思路：第一问就是求最长不上升子序列问题；第二问要求至少需要多少个序列才能覆盖所有的值。对于第二问采取贪心策略，每次让新加入的值放到已有子序列结尾小于新加入的并且是最小的里面，这样可以保证该序列后面可以放下更多的元素。

#include<iostream>
using namespace std;
const int N=1010;
int a[N],f[N],g[N];
int main()
{
	int n=0,res=0;
	while(~scanf("%d",&a[n])) n++;
	for(int i=0;i<n;i++)
	{
		f[i]=1;
		for(int j=0;j<i;j++)
		{
			if(a[i]<=a[j])
				f[i]=max(f[i],f[j]+1);
		}
		res=max(res,f[i]);//能拦截的最多导弹
	}
	int cnt=0;//需要的系统数量
	for(int i=0;i<n;i++)
	{
		int k=0;
		while(k<cnt&&a[i]>g[k]) k++;//已经是保证了新加入的一定会加入到序列最小值的后面，当a[i]不大于已有的的所有子序列，
									//那它就只能自己在创建一个新的序列，此事它最小，排在最后。
		g[k]=a[i];
		if(k>=cnt) cnt++;
	}
	printf("%d\n%d\n",res,cnt);
	return 0;
}

272. 最长公共上升子序列
思路：f[i][j]表示所有在1~i和1~j中出现的公共子序列，且以b[j](a[i])结尾的。划分，①不包含a[i]，即只在1~(i-1)和1~j中出现的f[i-1][j]；②包含a[i]：此时a[i]和b[j]都包含了，这时不考虑a[i]和b[j]了，只考虑1~(i-1)和1~(j-1),考虑b的倒数第二个数可能是谁，那么可能为b[1],b[2]...[j-1]或者没有，此时表达式f[i][j]=f[i-1][k]+1(1<=k<j)。优化，怎么出去k这重循环？看f[i-1][1],f[i-1][2]...f[i-1][j-1]，当j在进入下一次循环时，又有f[i-1][1],f[i-1][2]...f[i-1][j`-1],f[i-1][j-1],发现每次j进入循环时会重复计算上一次已经算过的，所以我们用一个maxn值来存储每次循环可以得到的一b[k]结尾的最大长度，即manx=max(maxn,f[i-1][k]+1），就可以避免重复计算多次了。

#include<iostream>
using namespace std;
const int N=3010;
int a[N],b[N],f[N][N];
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 maxn=1;//先置1表示f[i][j]以b[j]结尾的倒数第二个数b[k]为空的情况，那么就只有1种情况
		for(int j=1;j<=n;j++)
		{
			f[i][j]=f[i-1][j];//不包含a[i]
			if(a[i]==b[j])
			{
				f[i][j]=max(f[i][j],maxn);
			}
			if(b[j]<a[i])
				maxn=max(maxn,f[i-1][j]+1);//maxn存储1~(j-1)中可以以b[j]结尾的最长长度
		}
	}
	int res=0;
	for(int i=1;i<=n;i++)
		res=max(res,f[n][i]);
	printf("%d\n",res);
}

Codeforces Round #531 (Div. 3)

Dashboard - Codeforces Round #531 (Div. 3) - Codeforces (Unofficial mirror site, accelerated for Chinese users)

B - Array K-Coloring
思路：用一个二维数组来标记每个数字被那种颜色图上了可以避免相同数字涂上相同的颜色。同时先让所有颜色都被使用过一遍，之后后面的只需要考虑不要让相同数字涂上相同的颜色即可。
 

#include<iostream>
using namespace std;
const int N=5010;
int a[N],sum[N],ans[N],count[N][N],visit[N];
int main()
{
	int n,k,flag=0;
	scanf("%d%d",&n,&k);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
		sum[a[i]]++;
		if(sum[a[i]]>k)
			flag=1;
	}
	if(flag)
		printf("NO\n");
	else
	{
		int used=0;
		for(int i=0;i<n;i++)
		{		

			for(int j=1;j<=k;j++)
			{
				if(!count[a[i]][j]&&!visit[j]&&used<k)
				{
					count[a[i]][j]=1;//被使用过
					ans[i]=j;
					visit[j]=1;
					used++;
					break;
				}
				else if(used==k&&!count[a[i]][j])
				{
					ans[i]=j;
					count[a[i]][j]=1;
					break;
				}
			}
		}
		printf("YES\n");
		for(int i=0;i<n;i++)
			printf("%d ",ans[i]);
	}
	return 0;
}

C.Doors Breaking and Repairing

思路：当x>y时，一定可以使所有值变为0，因为无数次的轮流减x加y最后结果一定是小于等于0的。x<=y,一定是先把小于或等于x的值来减x，然后另一个一定会把小于等于x的值进行提升，一旦提升之后就不可能在减为0了。

#include<iostream>
using namespace std;
const int N=110;
int a[N];
int main()
{
	int n,x,y;
	scanf("%d%d%d",&n,&x,&y);
	for(int i=0;i<n;i++)
		scanf("%d",&a[i]);
	if(x>y)
		printf("%d\n",n);
	else
	{
		int count=0;
		for(int i=0;i<n;i++)
		{
			if(a[i]<=x)
				count++;
		}
		if(count%2==0)
			count/=2;
		else
			count=count/2+1;
		printf("%d\n",count);
	}
	return 0;
}

D. Balanced Ternary String
思路：0，1，2最后的数量一定是n/3的，所以先逐个比较那个的数量大于n/3的，如果是0的话，那么用依次用2，1从后面开始取代0的位置直至0的数量为n/3;同理，1的话，先让0从前往后取代1,再让2从后往前取代1；2的话，让0，1依次从前往后取代2。

#include<iostream>
using namespace std;
const int N=3e5+10;
int n,a[N],b[N],c[N];
char ch[N];
int main()
{
	scanf("%d%s",&n,ch);
	int o=0,p=0,q=0;
	for(int i=0;i<n;i++)
	{
		if(ch[i]=='0')
		{
			a[o++]=i;
		}
		else if(ch[i]=='1')
			b[p++]=i;
		else 
			c[q++]=i;
	}
	if(3*o>n)//0多
	{
		if(3*q<n)//2少
		{
			while(3*o>n&&3*q<n)
			{
				ch[a[--o]]='2';
				q++;
			}
		}
		if(3*p<n)
		{
			while(3*o>n&&3*p<n)
			{
				ch[a[--o]]='1';
				p++;
			}
		}
	}
	if(3*p>n)//1多
	{
		int t1=0,t=p;
		if(3*o<n)//0少
		{
			while(3*t>n&&3*o<n)
			{
				ch[b[t1++]]='0';
				t--;o++;
			}
		}
		if(3*q<n)
		{
			while(3*p>n&&3*q<n)
			{
				ch[b[--p]]='2';
				q++;
			}
		}
	}
	if(3*q>n)//2多
	{
		int t=0;
		if(3*o<n)
		{
			while(3*q>n&&3*o<n)
			{
				ch[c[t++]]='0';
				q--;o++;
			}
		}
		if(3*p<n)//1少
		{
			while(3*q>n&&3*p<n)
			{
				ch[c[t++]]='1';
				p++;
				q--;
			}
		}
	}
	printf("%s\n",ch);
	return 0;
}

E - Monotonic Renumeration
思路：对于a[i]==a[j]的，则从i~j这一段数组b的值都要一样，所以题意就成了寻找有多少段不相交的区间。之后对于每段区间的取值只有两种，要么与下一个区间值相等，要么比它小1，所以对于m段区间，有2^(m-1)中可能（除去b[0]这一段不用考虑）。先从前往后遍历数值a,记录相同值的数的最远下标，之后在继续遍历一遍，即进行左右区间的比较来判断是不是同一区间的。这里用来离散化来把a的每一个值映射到下标从0~n。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int N=2e5+10;
const int mod=998244353 ;
int n,a[N],t[N],r[N];
vector<int> alls;
int find(int x)
{
	int l=0,r=alls.size()-1;
	while(l<r)
	{
		int mid=l+r>>1;
		if(alls[mid]>=x)
			r=mid;
		else
			l=mid+1;
	}
	return l;
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
		t[i]=a[i];
	}
	sort(t,t+n);//先排序
	for(int i=0;i<n;i++)
	{
		alls.push_back(t[i]);
	}
	for(int i=0;i<n;i++)
	{
		a[i]=find(a[i]);//找到离散化后的下标
		r[a[i]]=i;//记录区间的最右端点
	}
	int nowr=0,num=1;//
	for(int i=0;i<n;i++)
	{
		if(i>nowr)//比较两个区间左右端点的位置，选择合并区间
		{
			num++;
		}
		nowr=max(nowr,r[a[i]]);
	}
	int res=1;
	while(num-1)
	{
		res=res*2%mod;
		num--;
	}
	printf("%d\n",res);
	return 0;
}

Codeforces Round #530 (Div. 2)https://codeforces.ml/contest/1099 

B. Squares and Segments
思路：每次画的时候往水平和垂直添边，使构成一个正方形，这样可以增加最少的边。小正方形的个数的是完全平方数的话，答案直接为sqrt(n)*2,否则用当前正方形的个数减去较外面的一个正方形的个数，可以得到剩下的正方形个数，判断这些个数要占用几列。

#include<iostream>
#include<algorithm>
#include<math.h>
using namespace std;
int main()
{
	int n,ans;
	scanf("%d",&n);
	int tmp=sqrt((double)n);
	if(sqrt((double)n)==tmp)
		ans=2*tmp;
	else
		ans=2*tmp+(n-tmp*tmp)/tmp+((n-tmp*tmp)%tmp!=0);
	printf("%d\n",ans);
	return 0;
}

没想好M
关注
第一章 动态规划 最长上升子序列模型
刘胖仔学后端
11-30 1587
我认为划分依据还是通过怎么来的来看的，这里倒数第二个到的倒数第一个，所以要按照这个划分 所代表的集合可以根据设问去看
动态规划之最长上升子序列模型
qq_52993545的博客
05-07 218
有些题目，让求给定序列的最*** 的 ***序列。 五一到了，ACM队组织大家去登山观光，队员们发现山上一个有N个景点，并且决定按照顺序来浏览这些景点，即每次所浏览景点的编号都要大于前一个浏览景点的编号。 同时队员们还有另一个登山习惯，就是不连续浏览海拔相同的两个景点，并且一旦开始下山，就不再向上走了。 队员们希望在满足上面条件的同时，尽可能多的浏览景点，你能帮他们找出最多可能浏览的景点数么？ 题目让求最长的子序列，该子序列满足单调递增或者先递增后递减或者递减。 我们要得到最长的子序列，就需要枚举出所有
2 最长上升子序列及其衍生
m0_63729880的博客
04-18 764
目录 最长上升子序列模板 1怪盗基德的滑翔翼 2 登山 3 合唱队形 4 友好城市 5 最长上升子序列和 最长上升子序列模板 信息学奥赛一本通（C++版）在线评测系统 (ssoier.cn) #include<bits/stdc++.h> using namespace std; const int N=1e3+10; int f[N],a[N]; int main() { int n,ans=0; cin>>n; for(i..
[线性dp] 最长公共上升子序列(最长上升子序列模型+最长公共子序列模型+经典+思维+状态划分)
Y-puyu 的博客
11-18 1285
文章目录0. 前言1. LIS +LCS+思维+状态划分 0. 前言 相关： [线性dp] 最长上升子序列(模板题+最长上升子序列模型) [线性dp] 最长公共子序列(模板题+最长公共子序列模型) 这是一道非常非常优秀的 LIS、LCS 问题。 1. LIS +LCS+思维+状态划分 272. 最长公共上升子序列 提前需要学习[线性dp] 最长公共子序列(模板题+最长公共子序列模型)的集合划分方式，很秀的一个方式。 重点： 线性 dp、LIS 问题、LCS 问题 思路： 状态定义： f[i][j] 所
[线性dp] aw895最长上升子序列(知识理解+重要模板题+最长上升子序列模型+LCS转化LIS)
Y-puyu 的博客
11-10 731
文章目录0. 前言1. 数字三角形+模板题 0. 前言 LIS（Longest Increasing Subsequence) 最长上升子序列 。 一个数的序列 bi，当 b1 < b2 < … < bS 的时候，我们称这个序列是上升的。对于给定的一个序列 (a1, a2, …, aN)，我们可以得到一些上升的子序列 (ai1, ai2, …, aiK)，这里 1 <= i1 < i2 < … < iK <= N。 比如，对于序列 (1, 7, 3, 5, 9
AcWing 1.2.1 最长上升子序列模型 + 动态规划 + 图解（详细）
呵呵哒!的博客
10-28 819
给定一个长度为 N 的整数序列。请你计算该序列的。上升子序列是指数值。
[AcWing] 187. 导弹防御系统（C++实现）最长上升子序列模型+贪心+dfs爆搜
cloud的博客
04-17 1448
[AcWing] 187. 导弹防御系统（C++实现）最长上升子序列模型+贪心+dfs爆搜1. 题目2. 读题（需要重点注意的东西）3. 解法4. 可能有帮助的前置习题5. 所用到的数据结构与算法思想6. 总结 1. 题目 2. 读题（需要重点注意的东西） 读题： 在[AcWing] 1010. 拦截导弹（C++实现）最长上升子序列模型+贪心的基础上，多了一个条件：导弹拦截系统可以是 严格上升 的子序列，也可以是 严格下降 的子序列，题目中给出的数各不相同。 思路： 最长上升子序列 + 贪心 + dfs
[AcWing] 1010. 拦截导弹（C++实现）最长上升子序列模型+贪心
cloud的博客
04-17 1997
[AcWing] 1010. 拦截导弹（C++实现）最长上升子序列模型+贪心1. 题目2. 读题（需要重点注意的东西）3. 解法4. 可能有帮助的前置习题5. 所用到的数据结构与算法思想6. 总结 1. 题目 2. 读题（需要重点注意的东西） 读题： 每来一个导弹有两种选择： 接在现有某个导弹拦截系统之后 创建一个新的导弹拦截系统 我们希望一个导弹拦截系统拦截的导弹足够的多（贪心），那么如果要将这个导弹加到某一个导弹拦截系统之后的话，我们需要从现有的所有导弹拦截系统中，找到一个结尾大于当前导
[线性dp] 最大上升子序列和(最长上升子序列模型+经典)
Y-puyu 的博客
11-17 255
文章目录0. 前言1. LIS 变种+经典变种 0. 前言 相关： [线性dp] 最长上升子序列(模板题+最长上升子序列模型) 1. LIS 变种+经典变种 1016. 最大上升子序列和 本题很考思维抽象。 重点： 线性 dp、LIS 问题、思维抽象 思路： 状态定义： f[i] 表示所有以 a[i] 结尾的上升子序列和的最大值 状态转移： 分类依据：倒数第二个数是哪个数，可将状态分类为倒数第二个数为空、为a[1]、a[2]、...、a[i-1]，总共是有 i 种情况，假设倒数第二个数是 a[k
最长上升子序列模型（LIS）
m0_74120503的博客
01-18 2624
最长上升子序列模型就像它的名字一样，用来从区间中找出最长上升的子序列。它主要用来处理区间中的挑选问题，可以处理上升序列也可以处理下降序列，原序列本身的顺序并不重要。
动态规划——最长上升子序列模型
pangyou3s的博客
03-25 1397
动态规划——最长上升子序列模型
【动态规划专题】最长上升子序列模型
繁凡さん的博客
07-28 531
A、AcWing 895. 最长上升子序列（模板） 给定一个长度为N的数列，求数值严格单调递增的子序列的长度最长是多少。 今天的最长上升子序列模型的基础 这里是一个O(n2)O(n^ 2)O(n2)的做法。可以用二分优化成O(nlogn)O(nlogn)O(nlogn) #include <iostream> #include <algorithm> #include <cstdio> using namespace std; const int N = 50007,
【AcWing算法提高课】1.2.1最长上升子序列(一)
m0_71477690的博客
07-02 229
AcWing算法提高课 1.2.1最长上升子序列(一)
算法：快排(三指针算法)
最新发布
qincjun的博客
11-16 154
快排：三指针算法
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
zhaoylzy的博客
11-16 905
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
1163：阿克曼(Ackmann)函数
呆萌很的博客
11-12 260
1163：阿克曼(Ackmann)函数
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1310
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
【循环测试试题3】小X与数字三角形
Lonely_Boos的博客
11-16 89
共n行，第i行包含i个正整数，每个整数占五列。读入一个正整数n，输出一个n行的数字三角形。一行一个正整数n，2
动态规划子序列问题解析：最长公共与上升子序列
"这篇内容主要讨论了动态规划在解决子序列问题中的应用，特别是最长公共子序列（LCS）的递归树分析和优化方法。" 动态规划是一种强大的算法思想，用于解决具有重叠子问题和最优子结构的问题。在这个上下文中，"dp之...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值