WEEK_4（DP初窥）

已于 2024-01-15 17:44:15 修改
阅读量137 收藏
点赞数
文章标签： 算法 动态规划
于 2023-11-04 16:17:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hycccccch/article/details/134219125
版权

P3637 最长上升子序列

该题为动规板子题，主要思路：如果一个上升子序列的最大值小于它后面的一个数，那么这个子序列的长度就可以增加1，即将这个数纳入子序列，并保留以这个数结束的最优情况，比较以各个数结束的最优情况，用max取出最大值

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e4+5;
int a[N];
int main()
{
	int n;
	cin>>n;
	int dp[N];
	for(int i=1;i<=n;i++)
	{
		cin>>a[i];
		dp[i]=1;
	}
	int maxx=1;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i-1;j++)
		{
			if(a[i]>a[j])
			dp[i]=max(dp[j]+1,dp[i]);
		}
		maxx=max(dp[i],maxx);
	}
	cout<<maxx;
	return 0;
}

P1115 最大字段和

比较后一个数与前一个数之前的的最优情况加上这个数后的大小，若后一个数较大，则没有必要用前面的数之和加上这个数，以这个数开始即可，相反，后一个数相对较小，则加上这个数，并依次比较下去，期间用max一直记录最大值

还是题解说得明白：

  • 如果一个数加上上一个有效序列得到的结果比这个数大，那么该数也属于这个有效序列。
  • 如果一个数加上上一个有效序列得到的结果比这个数小，那么这个数单独成为一个新的有效序列

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
int num[N],dp[N];
int main()
{
	int n;
	cin>>n;
	memset(num,0,sizeof(num));
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n;i++)
	cin>>num[i];
	int maxx=-2147483647;
	for(int i=1;i<=n;i++)
	{
		dp[1]=num[1];
		dp[i]=max(dp[i-1]+num[i],num[i]);
		maxx=max(dp[i],maxx);
	}
	cout<<maxx;
	return 0;
}

P8707  [蓝桥杯 2020 省 AB1] 走方格

从题目来看，不难得出结论：第1行以及第1列的所有位置都可自成一种情况，故都赋上1

然后开始对横坐标都为偶数的点进行标注，即赋值为0

最后可以得到状态转移方程：dp[i][j]=dp[i-1][j]+dp[i][j-1]

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=35;
int dp[N][N];
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	for(int j=1;j<=m;j++)
	dp[i][1]=1,dp[1][j]=1;
	for(int i=2;i<=n;i++)
	for(int j=2;j<=m;j++)
	{
		if(i%2==0&&j%2==0)
		dp[i][j]=0;
		else
		dp[i][j]=dp[i-1][j]+dp[i][j-1];
	}
	cout<<dp[n][m];
	return 0;
}

P1216 数字三角形 Number Triangles

本题属于数塔模型，解决思路为：先递后归

将问题先分为各个小部分，首先从上往下分析可得，数之和若要取得最优解，直接受决定于这个数下面的左右子树的最优解，以此类推，问题最终解需要从数塔的最底层开始找，然后进行每轮比较，最终得出最大值

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+5;
int dp[N][N];
int main()
{
	int r;
	cin>>r;
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=r;i++)
	for(int j=1;j<=i;j++)
	cin>>dp[i][j];
	int maxx=0;
	for(int i=r-1;i>=1;i--)
	{
		for(int j=1;j<=i;j++)
		{
			dp[i][j]+=max(dp[i+1][j],dp[i+1][j+1]);
			maxx=max(maxx,dp[i][j]);	
		}
	}
	cout<<maxx;
	return 0;
}

P1020 导弹拦截

这题真的ex，好好地o(n^{2})不行，非得o(n\log n)，

这是o(n^{2})代码：

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int main()
{
	int a[N],m=1,dp[N],ans=0;
	memset(dp,0,sizeof(dp));
	while(cin>>a[m])
	m++;
	m--;
	for(int i=1;i<=m;i++)
	{
		dp[i]=1;
		for(int j=1;j<=m;j++)
		{
			if(a[i]<=a[j]&&i!=j)
			dp[i]=max(dp[i],dp[j]+1);
		}
		ans=max(dp[i],ans);
	}
	cout<<ans<<endl;
	memset(dp,0,sizeof(dp));
	ans=0;
	for(int i=1;i<=m;i++)
	{
		dp[i]=1;
		for(int j=1;j<=m;j++)
		{
			if(a[i]>a[j]&&i!=j)
			dp[i]=max(dp[i],dp[j]+1);
		}
		ans=max(dp[i],ans);
	}
	cout<<ans;
  	return 0;
}

结果：

所以思前想后，如何利用二分查找解决此问题，是这样的：

第一个问题：

        此问题即找到一个最长非递增序列，那么可以先得到一个初始子序列，后一个数如果比最后一个数小，那么就接在这个数的后面，形成新一个子序列，但是如果比最后一个数大，就对其所在区间位置进行二分查找，并且替换掉较小数。（为了实现最长，则最后一个数越大就越有可能实现）一直进行下去直至最后，就可得到最终的最长非递增子序列

第二个问题：

        为了简化运算以及思路，引入Dilworth定理：

狄尔沃斯定理亦称偏序集分解定理，该定理断言：对于任意有限偏序集，其最大反链中元素的数目必等于最小链划分中链的数目。此定理的对偶形式亦真，它断言：对于任意有限偏序集，其最长链中元素的数目必等于其最小反链划分中反链的数目。

         在本题中，此定理的运用为：第二个问题可以转化成将第一个问题中的数反序排列，然后再求一遍最长非递增子序列，证明如下：

  • 当 n=1 时：命题显然成立。

  • 假设对于 n=k 结论成立，考虑 n=k+1 的情况：
    当 A 中最长链的长度为 k+1 时，令 M 为 A 中极大元的集合，显然 M 是一条反链。而且 A−M 中最长链的长度为 k。

由归纳假设，可以把 A−M 分成至少 k 个不相交的反链，加上反链 M，则 A 可分成至少 k+1 条反链。
因为 A 不可能分解成 n−1 条反链。假若只有 n−1 条反链，那么最长链的 n 个元素中必有 22 个元素被分到同一个反链，显然这与反链的定义矛盾。（摘自洛谷题解）

 代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int main()
{
	int m=1;
	int a[N];
	memset(a,0,sizeof(a));
	while(cin>>a[m])
	m++;
	m--;
	int d[N];
	memset(d,0,sizeof(d));
	int cou=1;
	d[1]=a[1];
	int xx=0;
	for(int i=2;i<=m;i++)
	{
		if(a[i]<=d[cou])
		{
			cou++;
			d[cou]=a[i];
		}
		else
		{
			int l=1,r=cou,mid=(r+l)>>1;
			while(l<r)
			{
				mid=(r+l)>>1;
				if(d[mid]<a[i])
				r=mid;
				else
				l=mid+1;
			}
			d[l]=a[i];
		}
	}
	cout<<cou<<endl;
	cou=1;
	reverse(a+1,a+1+m);
	memset(d,0,sizeof(d));
	d[1]=a[1];
	for(int i=2;i<=m;i++)
	{
		if(a[i]<d[cou])
		{
			cou++;
			d[cou]=a[i];
		}
		else
		{
			int l=1,r=cou,mid=(r+l)>>1;
			while(l<r)
			{
				mid=(r+l)>>1;
				if(d[mid]<=a[i])
				r=mid;
				else
				l=mid+1;
			}
			d[l]=a[i];
		}
	}
	cout<<cou;
	return 0;
}

以下是选做题：

AT_dp_f LCS

        最长公共子序列，英文缩写为LCS（Longest Common Subsequence）。定义为一个序列 S ，如果分别是两个或多个已知序列的子序列，且是所有符合此条件序列中最长的，则 S 称为已知序列的最长公共子序列。

求最大长度：

        对于本题，要对字符串1和字符串2依次进行遍历，判断每个字符是否一样，每当有相同字符出现的时候，进行一次dp，这时的dp只与字符串1前一位和字符串2的前一位有关，由于要找到最长子序列，故要将该字符纳入子串，即：

dp[i][j]=dp[i-1][j-1]+1

        当遍历到不相同的字符时，则根据动规的最有子序列的特性，此次情况与字符串1上一个字符以及字符串2遍历上一个字符的情况有关，最优的话，则取二者最大值，即：

dp[i][j]=max(dp[i-1][j],dp[i][j-1])

求最大子序列：

        说真的这个挺难想的，想要找到具体的子序列，正向遍历字符串肯定不行，因为不能判断在哪一步dp有最大值，或者说是通往最大值的解，因此需要从最后开始，倒着向前遍历dp，由于正向遍历时，dp是一个一个遍历上去的，故倒过来也是一样，分别从字符串1和字符串2的最后一位开始，若字符相同，则存入另一数组中，若不同，则判断字符串1上一位与字符串2上一位的dp大小，最后取最大的

代码如下：

#include<bits/stdc++.h>
using namespace std;
int dp[3010][3010];
char s[3010],t[3010],ans[3010];
int main()
{
	scanf("%s%s",s+1,t+1);
	int n=strlen(s+1),m=strlen(t+1);
	for(int i=1;i<=n;i++)
	for(int j=1;j<=m;j++)
	if(s[i]==t[j])
	dp[i][j]=dp[i-1][j-1]+1;
	else
	dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
	int i=n,j=m;
	while(dp[i][j]>0)
	{
		if(s[i]==t[j])
		ans[dp[i][j]]=s[i],i--,j--;
		else if(dp[i-1][j]>=dp[i][j-1])
		i--;
		else
		j--;
	}
	for(int i=1;i<=dp[n][m];i++)
	cout<<ans[i];
	return 0;
}

P2196 [NOIP1996 提高组] 挖地雷

看到这一题，想用爆搜，但还不会，qwq。。所以，用动规想了至少两天还没想出来，看题解也看不明白，谁懂啊，www

于是那天晚上发狠，弄不出来不睡觉了，终于，最后写出来了hhh

初始化：

        首先是要初始化，将每个隧道中地雷数赋给每一个dp[i]，作为初始值，一开始挖地雷当然从1开始，故pos赋值1

找到地雷数最大值：

思路是这样的：大循环从1开始依次遍历到n，内循环从1开始遍历到大循环的 i ，每次以 i 结尾时找到考虑前面 i 个数的能挖到地雷数目加上第 i 个隧道中的地雷数的最大值，即：

if(mp[j][i]&&dp[j]+di[i]>dp[i])

dp[i]=dp[j]+di[i]

用maxx将每一次dp[i]储存，最后就可得到所挖地雷数的最大值了

挖到最大地雷数步骤：

        每当判断出来可以挖到第 i 个隧道中的地雷时，将此时的隧道记入数组中，每个下标对应数组的值，每次判断出来后就用 i 指向 j （可以看做逐渐建立子树），再判断此dp[i]是否可以是最大值（可以看成一种树结点，每次更换 i 可以看做更换一个父节点，然后将其枝丫接上去），并赋给pos，这样下去，逐渐就找到了每一次 i 所对应的最优解，最后也将最优子树连接起来，最后按照数组值指向对应下标，将下表倒序输出即可

代码如下：

#include<bits/stdc++.h>
using namespace std;
int n;
const int N=35;
int mp[N][N];
int dp[N];
int di[N];
int so[N];
int pre[N];
int main()
{
	cin>>n;
	int pos;
	int maxx=0;
	memset(mp,0,sizeof(mp));
	memset(di,0,sizeof(di));
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n;i++)
	cin>>di[i];
	for(int i=1;i<=n;i++)
	for(int j=i+1;j<=n;j++)
	cin>>mp[i][j];
	for(int i=1;i<=n;i++)
	dp[i]=di[i];
	memset(so,0,sizeof(so));
	maxx=di[1],pos=1;
	for(int i=2;i<=n;i++)
	for(int j=1;j<i;j++)
	{
		if(mp[j][i]&&dp[j]+di[i]>dp[i])
		{
			dp[i]=dp[j]+di[i];
			so[i]=j;
		}
		if(maxx<dp[i])
		{
			pos=i;
			maxx=dp[i];
		}
	}
	int cnt=0;
	while(so[pos]!=0)
	{
		pre[++cnt]=pos;
		pos=so[pos];
	}
	pre[++cnt]=pos;
	reverse(pre+1,pre+1+cnt);
	for(int i=1;i<=cnt;i++)
	{
		cout<<pre[i];
		if(i!=cnt)
		cout<<" ";
	}
	cout<<endl;	
	cout<<maxx;
	return 0;
}

P1541 [NOIP2010 提高组] 乌龟棋

额

本题觉得含金量不大，思路很好想，因有4个数，直接开四维数组即可，每一次循环找到对应的上一步棋的最优解，从而找到大问题最优解

代码：

#include<bits/stdc++.h>
using namespace std;
const int N=41,M=125;
int n,m;
int grade[355];
int numm;
int num[5];
int step[N][N][N][N];
int a,b,c,d;
int main()
{
	memset(step,0,sizeof(step));
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	cin>>grade[i];
	for(int i=1;i<=m;i++)
	{
		cin>>numm;
		num[numm]++;
	}
	int r;
	step[0][0][0][0]=grade[1];
	for(int i=0;i<=num[1];i++)
	for(int j=0;j<=num[2];j++)
	for(int k=0;k<=num[3];k++)
	for(int l=0;l<=num[4];l++)
	{
		r=1+i+2*j+3*k+4*l;
		if(i!=0)
		step[i][j][k][l]=max(step[i-1][j][k][l]+grade[r],step[i][j][k][l]);
		if(j!=0)
		step[i][j][k][l]=max(step[i][j-1][k][l]+grade[r],step[i][j][k][l]);
		if(k!=0)
		step[i][j][k][l]=max(step[i][j][k-1][l]+grade[r],step[i][j][k][l]);
		if(l!=0)
		step[i][j][k][l]=max(step[i][j][k][l-1]+grade[r],step[i][j][k][l]);
	}
	cout<<step[num[1]][num[2]][num[3]][num[4]];
	return 0;
}

P2679 [NOIP2015 提高组] 子串

对于本题，四维数组挺好理解的，三维么，理解不了一点了。。。

四维数组其实很好想，分别对应四种状态

第一个状态，字符串A的每个字符

第二个状态，字符串B的每个字符

第三个状态，需要选出的子串数目

第四个状态，对此时字符串B的字符选或不选

但是这样会爆！！！

于是改用滚动数组，因为对于A的每个字符，存在选与不选两种情况（对应第四维的1和0），故只与上一个字符的最优解有关，则上面的方法需要存储的前 i-2种情况都可以删去，最终第 i 次只和第 i-1 次有关，所以

第一个状态，字符串A第 i 个字符与第 i-1个字符

可是要注意了，当A中有字符和B相等，此时对第 i 个字符有两种情况，即选与不选，选则有情况：纳入旧子串并使用前一个字符的，纳入新子串但不使用前一个字符，纳入新子串并使用前一字符，即：

dp[i%2][j][h][1]=dp[(i-1)%2][j-1][h-1][0]+dp[(i-1)%2][j-1][h][1])+dp[(i-1)%2][j-1][h-1][1];

若不相等了，则种数为前一字符所有情况之和，即：

dp[i%2][j][h][0]=dp[(i-1)%2][j][h][0]+dp[(i-1)%2][j][h][1];

P5322 [BJOI2019] 排兵布阵

这一题乍一看还是不太难的，再一看，是绿题，想着这也太不值了吧。。。

额额

可是这题让我知道，绿题是有它绿的原因的，太巧妙了hhh，这题别看它输入是一行行输士兵数，代表每个城堡对应的士兵数量，其实要把它倒过来看，把对每个城堡派去的士兵数看做一个集合，即对第 i 个城堡派去了5、3、4...进行这样一个巧妙地转换，就能使用背包算法了

最外面循环是对第 i 个城堡进行进攻，第二个循环是遍历攻打每个城堡的士兵数量，最里面一个循环，目的是遍历每个选手这样选择的情况数

当然了，作为背包问题，还是有一定模版的，只不过这题需要一个转的思想罢了，状态转移方程还是很友好的：

dp[j]=max(dp[j-2*stra[i][k]-1],dp[j])

代码如下：

#include<bits/stdc++.h>
using namespace std;
int s,n,m;
int stra[105][105];
int dp[20005];
int maxx=0;
int main()
{
	cin>>s>>n>>m;
	for(int i=1;i<=s;i++)
	for(int j=1;j<=n;j++)
	cin>>stra[j][i];
	for(int i=1;i<=n;i++)
	sort(stra[i]+1,stra[i]+1+s);
	for(int i=1;i<=n;i++)//第i个城堡 
	for(int j=m;j>=0;j--)//j个士兵 
	for(int k=1;k<=s;k++)//第k位选手 
	{
		if(j>2*stra[i][k])
		dp[j]=max(dp[j-2*stra[i][k]-1]+i*k,dp[j]);
	}
	cout<<dp[m];
	return 0;
}

hycccccch
关注
求一个数列的最长非递增（递减）子序列
zxxapple的专栏
03-09 1134
  问题描述： 给出一个数列，找出其中最长的单调递减（或递增）子序列。比如数列 4，2，6，3，1，5  最长递增子数列为2,3,5               相似的问题：1求最大和的子序列                               2最大公共子串                               3最大公共子序列             注意：串与...
【Android-Calender】DAY_OF_WEEK与DAY_OF_WEEK_IN_MONTH
dandelionela的博客
12-06 1395
1. 比较Calendar.DAY_OF_WEEK与Calendar.DAY_OF_WEEK_IN_MONTH 根据文档： int DAY_OF_WEEK Field number forgetandsetindicating the day of the week. int DAY_OF_WEEK_IN_MONTH Field number ...
【C++】洛谷B3637 最长上升子序列
Pharus的博客
12-19 1908
这是一个简单的动规板子题。给出一个由n(n≤5000)个不超过106的正整数组成的序列。请输出这个序列的的长度。最长上升子序列是指，从原序列中取出一些数字排在一起，这些数字是的。
【洛谷 B3637】最长上升子序列 题解（动态规划+最长上升子序列）
最新发布
HEX9CF的技术博客
04-25 1286
这是一个简单的动规板子题。给出一个由nn≤5000个不超过106的正整数组成的序列。请输出这个序列的的长度。最长上升子序列是指，从原序列中取出一些数字排在一起，这些数字是的。
最长上升/非降子序列，长度查找及输出序列(典型例题记录)
Khasehemwy的博客
10-08 226
复杂度均为 O(nlogn) 长度查找： int n; scanf("%d",&n); for (int i=1;i<=n;i++) scanf("%d",&a[i]); if (n==0) //0个元素特判一下 { printf("0\n"); return 0; } d[1]=a[1]; //初始化 int len=1; for (int i=2;i<=n;i++)
c语言连续非递减子序列,最长非递减子序列的应用
weixin_39830906的博客
05-22 204
Description我们有一个数列A1,A2...An，你现在要求修改数量最少的元素，使得这个数列严格递增。其中无论是修改前还是修改后，每个元素都必须是整数。请输出最少需要修改多少个元素。Input第一行输入一个$T (1 \leq T \leq 10)$，表示有多少组数据每一组数据：第一行输入一个$N (1 \leq N \leq 10^5)$，表示数列的长度第二行输入N个数$A_1, A_2...
week_4.ipynb
01-24
week_4.ipynb
Classwork_Sec_1_Week_5_ML.ipynb
02-08
Classwork_Sec_1_Week_5_ML.ipynb
week_9_1_tools.py
10-25
week_9_1_tools.py
Week_2_One_Piece_at_a_Time_Daan.ipynb
09-15
Week_2_One_Piece_at_a_Time_Daan.ipynb
动态规划——最长子序列、子串问题
chuangshangbeidong的博客
10-25 2057
动态规划——最长（连续）子序列问题0 未完成，待续1. 概述2. 最长子序列（不要求连续）3. 最长连续子序列 0 未完成，待续 1. 概述 其实本问题有两大类，一类是要求连续的，一类是要求不连续的。 先来看子序列与子串的区别，已知原数组为 1, 2, 4, 3, 7, 6, 5] ，则： [1, 2, 4] 为原数组的子串，三个元素收尾相连，中间没有别的元素； [1, 3, 5] 为子序列，各个元素之间可能隔着别的元素。 2. 最长子序列（不要求连续） 3. 最长连续子序列 一维数组，动规数组定义为
DP专题--B3637 最长上升子序列
Silver_Bullet的博客
12-19 480
DP 动态规划
【洛谷 B3637】最长上升子序列 题解（动态规划+耐心排序+lower_bound+最长上升子序列）
HEX9CF的技术博客
04-25 767
这是一个简单的动规板子题。给出一个由nn≤5000个不超过106的正整数组成的序列。请输出这个序列的的长度。最长上升子序列是指，从原序列中取出一些数字排在一起，这些数字是的。
最长上升子序列
Shen_Ji_的博客
12-16 2013
算dp[ 6 ]时，因为a[ 6 ]>a[ 1 ]且a[ 6 ]>a[ 2 ]且a[ 6 ]>a[ 5 ]，所以dp[ 6 ]=max(dp[ 1 ],dp[ 2 ], dp[ 5 ])+1=4。算dp[ 3 ]时，因为a[ 3 ]>a[ 1 ]且a[ 3 ]>a[ 2 ]，所以dp[ 3 ]=max(dp[ 1 ],dp[ 2 ])+1=3。算dp[ 5 ]时，因为a[ 5 ]>a[ 1 ]且a[ 5 ]>a[ 2 ]，所以dp[ 5 ]=max(dp[ 1 ],dp[ 2 ])+1=3。
洛谷B3637 最长上升子序列|线性DP、模板题
qq_61814350的博客
04-02 526
1.首先，没有初始化每个dp元素，误以为总有一个 dp[i]=max(dp[i],dp[j]+1);会把当前的dp赋值为1，然而。虽然这道题已经见过很多类似的变形了，但是还是犯迷糊。2.忘记了还要在每个dp元素里再找一个最大的。，所以需要手动初始化为1。
洛谷 B3637 最长上升子序列
小 P 的博客
08-04 531
最长上升子序列 - 洛谷。
B3637 最长上升子序列
2301_77920554的博客
08-03 387
这是一个简单的动规板子题。给出一个由nn≤5000个不超过106的正整数组成的序列。请输出这个序列的的长度。最长上升子序列是指，从原序列中取出一些数字排在一起，这些数字是的。
最长上升子序列 洛谷B3637
PengFly123的博客
12-04 449
动态规划-最长上升子序列
【洛谷】 B3637 最长上升子序列
Heait的博客
02-17 710
这是一个简单的动规板子题。给出一个由nn≤5000个不超过106的正整数组成的序列。请输出这个序列的的长度。最长上升子序列是指，从原序列中取出一些数字排在一起，这些数字是的。
java Calendar.WEEK_OF_YEAR
07-08
`Calendar.WEEK_OF_YEAR` 是一个常量，用于表示一年中的第几周的字段。在 Java 中，可以使用 `java.util.Calendar` 类来获取给定日期所在年份的周数。 以下是一个示例代码，演示如何使用 `Calendar` 类获取指定日期...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值