动态规划练习

最新推荐文章于 2024-10-31 16:16:13 发布
最新推荐文章于 2024-10-31 16:16:13 发布
阅读量76 收藏
点赞数
分类专栏： 算法 文章标签： 动态规划 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62994512/article/details/129008084
版权
本文通过一系列编程题目展示了动态规划在解决序列格子类和背包类问题中的应用，包括数字金字塔、最长不下降序列、拦截导弹等，每个问题都详细解析了状态定义、状态转移方程和边界条件，帮助读者深入理解动态规划的思路和方法。
摘要由CSDN通过智能技术生成

        动态规划的练习题分为序列格子类的和背包类的

文章主要是序列格子类的问题，题目来自信息学奥数的题目，对于初学者比较友好

信息学奥数一本通的链接 信息学奥赛一本通（C++版）在线评测系统 (ssoier.cn)

1.数字金字塔

//dp-xxxas1258-数字金字塔
/*
1.状态的定义和描述
dp[i][j] 从点（1，1）到点（i，j）途径数字最大
2.状态转移方程
dp[i][j]=max(dp[i-1][j],dp[i-1][j-1])+a[i][j];
3.找准边界 

*/ 
#include<stdio.h>
int max(int a,int b);
int a[1001][1001];
int n;
int dp[1001][1001];
int maxx=0;
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			scanf("%d",&a[i][j]);
		}
	}
	dp[1][1]=a[1][1];
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			dp[i][j]=max(dp[i-1][j],dp[i-1][j-1])+a[i][j];
		}
	}
	for(int i=1;i<=n;i++)
	{
		if(dp[n][i]>maxx)
			maxx=dp[n][i];
	}
	printf("%d",maxx);
	
 } 
 
 int max(int a,int b)
 {
 	if(a>b)
 		return a;
 	else
 		return b;
 }

2.求最长不下降序列

注意审题，最长不下降序列意味着序列可以有相等的元素

//dp-xxxas1259-求最长不下降子序列
/*
1.状态的定义和描述
dp[i] 第i个元素最为结尾的最长不下降子序列
2.状态转移方程
if(a[i]>=a[j])
{
	dp[i]=max(dp[i],dp[j]+1);
}
3.找准边界
若都不满足则它自身也是一个子序列，dp[i]=1; 
*/ 
#include<stdio.h>
int max(int a,int b);
void print(int maxidex);
int n;
int a[201];
int dp[201];
int pre[201];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		dp[i]=1;
	}
	int maxx=1;
	int maxidex=1;
	for(int i=2;i<=n;i++)//当i=2时，j往前找 
	{
		for(int j=1;j<i;j++)
		{
			if(a[i]>=a[j])//这样就说明可以加在j后面 
			{
				//还需要判断它是否大
				 if(dp[j]+1>dp[i])
				 {
				 	pre[i]=j;//在i下标点的这个元素，它的前驱是j
					dp[i]=dp[j]+1; 
				  } 
			 } 
		}
		if(dp[i]>maxx)
		{
			maxx=dp[i];
			maxidex=i;//记录最长不下降子序列的下标 
		}
	}
	printf("max=%d\n",maxx);
	print(maxidex); 
	return 0;
}
int max(int a,int b)
 {
 	if(a>b)
 		return a;
 	else
 		return b;
 }
 
 void print(int maxidex)
 {
 	if(maxidex==0)
 		return;
 	print(pre[maxidex]);//调用函数递归 
 	printf("%d ",a[maxidex]);
 }

3.拦截导弹

        注意审题然后对应到相应的类型题目中去，这个题对应的就是最长上升子序列和最长下降子序列

//dp-xxxas1260-拦截导弹 
/*
1.状态的定义和描述
dp_down[i] i下标元素为结尾的最长不上升子序列
dp_up[i] i下标元素为结尾的最长上升子序列
2.状态转移
if(a[i]<=a[j])//说明i下标元素大于j下标元素 
{
	dp_down[i]=max(dp_down[i],dp_down[j]+1);
}
else
{
	dp_up[i]=max(dp_up[i],dp_up[j]+1); 
} 
3.找准边界 
*/
#include<stdio.h>
int max(int a,int b);
int n=1;
int a[1001];
int dp_down[1001];
int dp_up[1001];
int main(void)
{
	while(scanf("%d",&a[n])!=EOF)
	{
		dp_down[n]++;
		dp_up[n]++;
		n++;
	}
	n--;
	int max_up=1,max_down=1;
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j]) 
			{
				dp_up[i]=max(dp_up[i],dp_up[j]+1);
			}
			else
			{
				dp_down[i]=max(dp_down[i],dp_down[j]+1);//上升子序列
			} 
		}
		if(dp_down[i]>max_down)
			max_down=dp_down[i];
		if(dp_up[i]>max_up)
			max_up=dp_up[i];
	}
	printf("%d\n%d\n",max_down,max_up);
	return 0;
 } 
int max(int a,int b)
 {
 	if(a>b)
 		return a;
 	else
 		return b;
 }

4.城市交通路网

        这个题相对复杂，分析题目从最后一个开始，找到每个元素到终点的最小值，到起点的时候就变遍历起点紧挨着的数，然后在查紧挨着的数到终点的距离

//dp-xxxas1261-城市交通路网
/*
1.状态的定义和描述 
dp[i]  i这个城市到指定的最后一个城市的最短路径
2.状态转移方程
dp[i]=min(dp[i],a[i][j]+dp[j]);
3.找准边界
当a[i][j]==0;的时候i到j这个城市是断开的，不相连的 
*/ 
#include<stdio.h>
#define INF 0x3f3f3f3f
int min(int a,int b);
void print(int i);
int n;
int a[1001][1001];
int dp[1001];
int pre[1001];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			scanf("%d",&a[i][j]);
		}
		dp[i]=INF;
	}
	dp[n]=0;
	pre[n]=0;
	for(int i=n-1;i>0;i--)//从最后一个元素开始 
	{
		for(int j=i+1;j<=n;j++)
		{
			if(a[i][j]!=0&&a[i][j]+dp[j]<dp[i])
			{
			//dp[i]=min(dp[i],a[i][j]+dp[j]);
					dp[i]=a[i][j]+dp[j];
					pre[i]=j;
			}
		 } 
	}
	printf("minlong=%d\n",dp[1]);
	print(1);
	return 0;
 } 
 int min(int a,int b)
 {
 	if(a<b)
 		return a;
 	else
 		return b;
 }
 void print(int i)
 {
 	printf("%d ",i);
 	if(pre[i]==0)
 		return ;
 	print(pre[i]);
 }

5.挖地雷

        和上一个题类似

//dp-xxxas1262-挖地雷
/*
1.状态描述以及定义
dp[i]  从i点到终点挖到的地雷最大值
2.状态转移
for(int j=1;j<=n;j++)
{
	dp[i]=max(dp[i],dp[j]+a[i]);
}
3.找准边界 
*/ 
#include<stdio.h>
int n;
int a[201];
int arr[201][201];
int dp[201];
int nestidex[201];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		dp[i]=a[i];
	}
		
	int c,b;
	while(scanf("%d %d",&c,&b)==2&&a!=0&&b!=0)
		arr[c][b]=1;//等于1说明a到b可通 
	 
	int maxx=0;
	int maxindex=0;
	for(int i=n-1;i>0;i--)
	{
		for(int j=i+1;j<=n;j++)
		{
			if(arr[i][j]==1&&dp[i]<dp[j]+a[i])
			{
				dp[i]=dp[j]+a[i];
				nestidex[i]=j;//记录的是后驱,用递归打印 
			}
		}
		if(dp[i]>maxx)
		{
			maxx=dp[i];
			maxindex=i;
		}
	 } 
	 while(nestidex[maxindex])
	 {
	 	printf("%d-",maxindex);
	 	maxindex=nestidex[maxindex];
	 }
	 printf("%d",maxindex);
	 printf("\n%d",maxx); 
	return 0;
 }

6.友好城市

        这题蛮有意思的，用笔依次画出来就能够找出规律，就会发现特别奇妙

//dp-xxxas1263-友好城市
/*
1.状态描述以及定义
dp[i]  以i点结尾的最长递增子序列 
2.状态转移
for(int j=1;j<=n;j++)
{
	dp[i]=max(dp[i],dp[j]+1);
}
3.找准边界 
 
*/
#include<stdio.h>
void sort();
int max(int a,int b);
int n;
int a[5001];
int b[5001];
int dp[5001];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d %d",&a[i],&b[i]);
		dp[i]=1;
	}
	sort();
	int maxx=0;
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<i;j++)
		{
			if(b[i]>b[j])
				dp[i]=max(dp[i],dp[j]+1);
		}
		if(dp[i]>maxx)
			maxx=dp[i];
	}
	printf("%d",maxx);
	return 0;
 } 
 void sort()
 {
 	for(int i=1;i<n;i++)
 	{
 		for(int j=i+1;j<=n;j++)
 		{
 			if(a[i]>a[j])
 			{
 				int temp=a[i];
 				a[i]=a[j];
 				a[j]=temp;
 				
 				temp=b[i];
 				b[i]=b[j];
 				b[j]=temp;
			 }
		 }
	 }
 }
 int max(int a,int b)
 {
 	if(a>b)
 		return a;
 	else
 		return b;
 }

7.合唱队形

        这个题就是最长上升子序列的套牌，只是起点不同，根据题意需要从起点开始进行最长上升子序列的计算和从末尾开始的最长上升子序列的计算，然后从dp表中在找到最佳值

//dp-xxxas1264-合唱队形 
/*
1.状态描述以及定义
dp_1_up[i]  从1这个点到i点结尾的最长上升子序列 
dp_n_up[i]  从n这个点到i点结尾的最长上升子序列 
2.状态转移
for(int j=1;j<=n;j++)
{
	if(a[i]>a[j])
	{
		dp[i]=max(dp[i],dp[j]+1);
	}
}
3.找准边界 
dp描述的出发点不一样 
*/
#include<stdio.h>
int max(int a,int b);
int n;
int a[101];
int dp_1_up[101];
int dp_n_up[101];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		dp_1_up[i]=1;
		dp_n_up[i]=1;
	}
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j])
			{
				dp_1_up[i]=max(dp_1_up[i],dp_1_up[j]+1);
			}
		}
	}
	for(int i=n-1;i>0;i--)
	{
		for(int j=n;j>i;j--)
		{
			if(a[i]>a[j])
			{
				dp_n_up[i]=max(dp_n_up[i],dp_n_up[j]+1);
			}
		}
	}
	int maxx=0;
	for(int i=1;i<=n;i++)
	{
		if(dp_n_up[i]+dp_1_up[i]-1>maxx)
			maxx=dp_n_up[i]+dp_1_up[i]-1;
	}
	printf("%d",n-maxx);//表示最少要抽出去的人 
	return 0;
}
int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}

8.最长公共子序列

模板题目了

//dp-xxxas1265-最长公共子序列 
/*
1.状态描述以及定义
dp[i][j]  字符串a[i] 下标i之前的字符串与 字符串b[j] 下标j之前的字符串的最长公共子序列 
2.状态转移
if(a[i]==b[j])
{
	dp[i][j]=dp[i-1][j-1]+1;
}
else
{
	dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
}
3.找准边界 
边界是从0开始的 
*/
#include<stdio.h>
#include<string.h>
int max(int a,int b);
char a[1001];
char b[1001];
int dp[1001][1001];
int main(void)
{
//	gets(a);
//	gets(b);
	scanf("%s %s",a,b);
	//初始化dp表 
	//a为行 
	int log=0;
	for(int i=0;i<strlen(a);i++) 
	{
		if(b[0]==a[i]&&log==0)
			log=1;
		if(log==1)
			dp[0][i]=1;
		else
			dp[0][i]=0;	
	}
	log=0;
	for(int i=0;i<strlen(b);i++) 
	{
		if(b[i]==a[0]&&log==0)
			log=1;
		if(log==1)
			dp[i][0]=1;
		else
			dp[i][0]=0;
	}
	//dp操作
	for(int i=1;i<strlen(b);i++)
	{
		for(int j=1;j<strlen(a);j++)
		{
			if(b[i]==a[j])
				dp[i][j]=dp[i-1][j-1]+1;
			else
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
		}
	 } 
	printf("%d",dp[strlen(b)-1][strlen(a)-1]);
	return 0;
}
int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}

9.机器分配

这个题蛮有意思的，对我来说理清楚还是花了一点时间的

//dp-xxxas1266-机器分配 
/*
1.状态描述以及定义
dp[i][j]  第i个公司分配j个机器的最大收益 
2.状态转移
dp[i][j]=max(dp[i][j],dp[i-1][j-k]+a[i][k]) 
3.找准边界 
边界是从0开始的 
*/
#include<stdio.h>
int max(int a,int b);
void print(int x,int y);
int m,n;//设备m台，公司n个
int a[16][16];
int dp[16][16];
int nestidex[16][16];//第i个公司在面临j台机器的时候选择了k台 
int main(void)
{
	scanf("%d %d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			scanf("%d",&a[i][j]);
		}
	}

	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			for(int k=0;k<=j;k++)
			{
				//dp[i][j]=max(dp[i][j],dp[i-1][j-k]+a[i][k]);
				/*a[i][k]可以理解为i公司选k=0时间就是不选，全部留给上一个公司，都是同时选择两个看看谁的大
				 若k=1，所以就要找到dp[i-1][j-1],找到上一个公司，比如说都选两个找到上一个公司选择一个的时候
				 然后比较大小，这个k的操作，我认为是一个经典，记住 
				 */
				if(dp[i][j]<dp[i-1][j-k]+a[i][k])
				{
					dp[i][j]=dp[i-1][j-k]+a[i][k];
					nestidex[i][j]=k;
					//这里的标记数组nestidex[i][j]=k 
				}
			}
		}
	}
	printf("%d\n",dp[n][m]); 
	print(n,m); 
	return 0;
 } 
int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}
void print(int x,int y)
{
	if(x==0) return ;
	print(x-1,y-nestidex[x][y]);
	printf("%d %d\n",x,nestidex[x][y]);
}

10.最长上升子序列

模板题

//dp-xxxas1267-最长上升子序列 
/*
1.状态描述以及定义
dp[i] 以i结尾的最长上升子序列 
2.状态转移
if(a[i]>a[j])
{
	dp[i]=max(dp[i],dp[j]+1); 
}
3.找准边界 

*/
#include<stdio.h>
int max(int a,int b);
int n;
int a[1001];
int dp[1001];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		dp[i]=1;
	}
	int maxx=0;
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j])
				dp[i]=max(dp[i],dp[j]+1);
		}
		if(dp[i]>maxx)
			maxx=dp[i];
	}
	printf("%d",maxx);
	return 0;
 } 
int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}

11.最大子矩阵

这也是一个模板题，前缀和要好好理解

//dp-xxxas1282-最大子矩阵
/*
1.状态描述以及定义
dp[i] 最大字段和 
2.状态转移
dp[i]=max(dp[i],dp[i-1]+dp[i]); 

3.找准边界  
*/ 
#include<stdio.h>
int max(int a,int b); 
int n;
int a[101][101];
int dp[101];
int presum[101][101];//前缀和 
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			scanf("%d",&a[i][j]);
			presum[i][j]=presum[i-1][j]+a[i][j];
		}
	}
	int maxx=a[1][1];
	for(int x1=1;x1<=n;x1++)
	{
		for(int x2=x1;x2<=n;x2++)//上面两个都是控制行的，就是通过这个x1，x2来控制presum数组 
		{
			for(int j=1;j<=n;j++)//操作合并列，进行降维 
			{
				dp[j]=presum[x2][j]-presum[x1-1][j]; 
			 } 
			for(int i=1;i<=n;i++)
			{
				dp[i]=max(dp[i],dp[i-1]+dp[i]);//状态转移，要么自己成一个 
				maxx=max(maxx,dp[i]);
			}
		}
	}
	printf("%d",maxx);
	return 0;
 } 
 int max(int a,int b)
 {
 	return (a>b)?a:b;
 }

12.登山

这个题和上面的合唱类似

//dp-xxxas1283-登山 
/*
1.状态描述以及定义
dp1_up[i] 起点从1开始，的最长上升子序列
dpn_up[i] 起点从n开始，的最长上升子序列 
2.状态转移
if(a[i]>a[j])
{
	dp[i]=max(dp[i],dp[j]+1); 
}
3.找准边界 

*/
#include<stdio.h>
int max(int a,int b);
int n;
int a[1001];
int dp1_up[1001];
int dpn_up[1001];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		dp1_up[i]=1;
		dpn_up[i]=1;
	}
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j])
				dp1_up[i]=max(dp1_up[i],dp1_up[j]+1);
		}
	}
	for(int i=n-1;i>0;i--)
	{
		for(int j=n;j>i;j--)
		{
			if(a[i]>a[j])
				dpn_up[i]=max(dpn_up[i],dpn_up[j]+1);
		}
	}
	int maxx=0;
	for(int i=1;i<=n;i++)
	{
		if(dp1_up[i]+dpn_up[i]-1>maxx)
			maxx=dp1_up[i]+dpn_up[i]-1;
	}
	printf("%d",maxx);
	return 0;
}
int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}

12.摘花生

走格子类问题

//dp-xxxas1284-摘花生 
/*
1.状态描述以及定义
dp[i][j] 从起点到(i,j)点最大采摘花生数 
2.状态转移
dp[i][j]=max(dp[i-1][j],dp[i][j-1])+a[i][j];
3.找准边界 

*/
#include<stdio.h>
int max(int a,int b);
int t;
int aa,bb;
int a[101][101];
int dp[101][101];
int main(void)
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d %d",&aa,&bb);//aa表示行，bb表示列
		for(int i=1;i<=aa;i++)
		{
			for(int j=1;j<=bb;j++)
			{
				scanf("%d",&a[i][j]);
				dp[i][j]=a[i][j];
			}
		 } 
		 
		for(int i=1;i<=aa;i++)
		{
			for(int j=1;j<=bb;j++)
			{
				dp[i][j]=max(dp[i-1][j],dp[i][j-1])+a[i][j];
			}
		 } 
		
		printf("%d\n",dp[aa][bb]);
	}
	return 0;
}
int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}

13.最大上升子序列和

模板题

//dp-xxxas1285-最大上升子序列和 
/*
1.状态描述以及定义
dp[i] 以i点结尾的最大上升子序列和 
2.状态转移
dp[i]=max(dp[i],dp[j]+a[i]); 
3.找准边界 
从i=1;开始 
*/
#include<stdio.h>
int max(int a,int b);
int n;
int a[1001];
int dp[1001];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		dp[i]=a[i];
	}
	
	int maxx=dp[0];
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<i;j++)
		{
			if(a[i]>a[j])
				dp[i]=max(dp[i],dp[j]+a[i]);
		}
		if(dp[i]>maxx)
			maxx=dp[i];
	}
	printf("%d",maxx);
	return 0;
}
int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}

14.怪盗基德的滑翔翼

认真审题会发现就是模板题目变个描述方式

//dp-xxxas1286-怪盗基德的滑翔翼 
/*
1.状态描述以及定义
dp1_up[i] 从1开始 以i作为结尾最大上升子序列 
dpn_up[i] 从n开始 以i作为结尾最大上升子序列 
2.状态转移
if(a[i]>a[j])
	dp_down[i]=max(dp_down[i],dp_down[j]+1);	

3.找准边界  
*/
#include<stdio.h>
int max(int a,int b);
int t;
int n;
int a[101];
int dp1[101];
int dpn[101];
int main(void)
{
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&a[i]);
			dp1[i]=1;
			dpn[i]=1;
		}
		int max1=1;
		for(int i=2;i<=n;i++)
		{
			for(int j=1;j<i;j++)
			{
				if(a[i]>a[j])
					dp1[i]=max(dp1[i],dp1[j]+1);	
			}
			if(max1<dp1[i])
				max1=dp1[i];
		}
		
		int maxn=1;
		for(int i=n-1;i>0;i--)
		{
			for(int j=n;j>i;j--)
			{
				if(a[i]>a[j])
					dpn[i]=max(dpn[i],dpn[j]+1);
			}
			if(dpn[i]>maxn)
				maxn=dpn[i];
		}
		printf("%d\n",max(maxn,max1));
	}
	return 0;
}
int max(int a,int b)
{
	return a>b?a:b;
}

15.最低通行费最低通行费

走格子问题

//dp-xxxas1287-最低通行费 
/*
1.状态描述以及定义
dp[i][j] 从起点到[i][j]点的最大和 
2.状态转移
dp[i][j]=min(dp[i][j-1],dp[i-1][j])+a[i][j]; 
3.找准边界 
从i=1开始 
求最小值要初始化边界，因为边界是0会影响最小值的判断 
*/
#include<stdio.h>
int min(int a,int b);
int n;
int a[101][101];
int dp[101][101];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			scanf("%d",&a[i][j]);
		}
	}
	//初始化 
	dp[1][1]=a[1][1];
	for(int i=2;i<=n;i++)//初始化行 
		dp[1][i]=dp[1][i-1]+a[1][i]; 
	for(int i=2;i<=n;i++)//初始化列 
		dp[i][1]=dp[i-1][1]+a[i][1]; 
		
	for(int i=2;i<=n;i++)
		for(int j=2;j<=n;j++)
			dp[i][j]=min(dp[i][j-1],dp[i-1][j])+a[i][j];
	
	printf("%d",dp[n][n]);
	return 0;
 } 
int min(int a,int b)
{
	if(a>b)
		return b;
	else
		return a;
}

16.三角形最佳路径问题

//dp-xxxas1288-三角形最佳路径问题 
/*
1.状态描述以及定义
dp[i][j] 从起点到[i][j]点的最大和 
2.状态转移
dp[i][j]=max(dp[i-1][j],dp[i-1][j-1])+a[i][j]; 
3.找准边界 
从i=1开始 
求最小值要初始化边界，因为边界是0会影响最小值的判断 
*/
#include<stdio.h>
int max(int a,int b);
int n;
int a[101][101];
int dp[101][101];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			scanf("%d",&a[i][j]);
	
	int maxx=dp[1][1]=a[1][1];
	
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			dp[i][j]=max(dp[i-1][j],dp[i-1][j-1])+a[i][j]; 
			if(dp[i][j]>maxx)
				maxx=dp[i][j];
		}
	}
	
	printf("%d",maxx);
	return 0;
}
int max(int a,int b)
{
	if(a>b)
		return a;
	else
		return b;
}

17.拦截导弹

//dp-xxxas1289-拦截导弹 
/*
1.状态描述以及定义
dp_down[i] 以i为结尾的最长递减子序列 用于计算最大能够拦截的导弹 
dp_up[i] 以i为结尾的最长递增子序列 用于计算系统数量 
2.状态转移
if(a[i]<a[j])
	dp_down[i]=max(dp_down[i],dp_down[j]+1);	
if(a[i]>a[j])
	dp_up[i]=max(dp_up[i],dp_up[j]+1);

3.找准边界 
从i=1开始 
求最小值要初始化边界，因为边界是0会影响最小值的判断 
*/
#include<stdio.h>
int max(int a,int v);
int n;
int a[16];
int dp_down[16];
int main(void)
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		dp_down[i]=1;
	}
	int maxdown=0;
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<i;j++)
		{
			if(a[i]<a[j])
				dp_down[i]=max(dp_down[i],dp_down[j]+1);
		}
		if(dp_down[i]>maxdown)
			maxdown=dp_down[i];
	}
	printf("%d",maxdown);
	return 0;
}
int max(int a,int v)
{
	if(a>v)
		return a;
	else
		return v;
}

照洋
关注
专栏目录
基础C语言（2）及练习题目
weixin_45396618的博客
12-25 478
一. short 2字节16bit -215~215-1 无符号时0,255 int 4 32 -231~231 float小数点后面可以精确到6-7位，后面的就无法确定 double 15-16位 ± 1.79*10^308 0.0（-0.0000001,0.0000001）这个范围 如果表达式是混合类型，那么窄字节会自动扩充为宽字节数据进行运算 short->int->long->long long->float->double char->int if
CCF201503-01
hua111hua的博客
08-21 145
#include&lt;iostream&gt; using namespace std; int a[1001][1001]; int main(){     int m,n;     cin&gt;&gt;m&gt;&gt;n;     for(int i=0;i&lt;m;i++){         for(int j=0;j&lt;n;j++){             cin&gt;&g...
c语言三种基本排序方法,三种基本排序方法(C语言实现)
weixin_39962394的博客
05-23 1748
三种基本排序(以升序为例)1.冒泡排序思想:每次相邻两个数比较,若升序,则将大的数放到后面,一次循环过后，就会将最大的数放在最后.如图9 3 2 5 8 4 7 6是输入的待排序的数列,经过第一次排序,将最大的9放在最后,第二次排序,将剩下的2 3 5 4 7 6 8进行冒泡,将当前最大的8放在倒数第二的位置,以此类推接下来上代码#include int main(void){int a[1001...
【c语言】排列数
是派大星吖的博客
04-03 1380
#include <stdio.h> int a[1001],b[1001],num; int f(int m,int n,int k){ // 从m个中选n个进行排列，k起始位置 int i,j; for(i=1;i<=m;i++){ if(!b[i]){ // 判断i是否可用,是否满足条件 a[k]=i; // 保存结果 b[i]=1; // 标志位置一，表示该数字已被使用 if(k==n){ // 是否已经取了n个数 .
int (*a)[10] 和 int *a[10] 的区别
boulders的博客
10-10 2万+
数组与指针 类别
动态规划练习1
08-03
动态规划是一种解决问题的有效方法，常用于优化复杂度和解决具有重叠子问题特性的任务。在给定的题目中，有三个与动态规划相关的部分，我们将逐一解析。 首先，我们来看第一部分，这是一个经典的0/1背包问题。设g(i...
动态规划练习题目！！
07-24
### 动态规划练习题知识点 动态规划是一种通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常用于求解最优化问题，其中涉及多阶段决策过程，每一阶段都需做出最优选择。动态规划法避免了枚举...
动态规划练习(pascal)
07-27
在这个"动态规划练习(pascal)"的资源中，我们重点探讨的是如何利用Pascal语言来实现动态规划算法。Pascal是一种结构化编程语言，它清晰的语法结构使得学习和应用动态规划算法变得相对直观。 动态规划的核心是将一个...
动态规划练习题及解答1.doc
09-10
动态规划练习题及解答1.doc
A - 1001
Orz
04-02 289
Description There is a mysterious organization called Time-Space Administrative Bureau (TSAB) in the deep universe that we humans have not discovered yet. This year, the TSAB decided to elect an ou
c语言1001 字符串连接,P1001 （C语言代码）
weixin_30453651的博客
05-22 245
解题思路:注意事项:参考代码:#include#includeint Confirm(int n){//确定是否为质数if(n<2)return 0;for(int i=2;i<=sqrt(n);i++){if(n%i==0)return 0;}return 1;}int main(){int n,k;int a[10000];scanf("%d %d",&n,...
三种基本排序方法(C语言实现)
热门推荐
qq2071114140的博客
05-24 14万+
三种基本排序(以升序为例) 1.冒泡排序 思想:每次相邻两个数比较,若升序,则将大的数放到后面,一次循环过后，就会将最大的数放在最后. 如图9 3 2 5 8 4 7 6是输入的待排序的数列,经过第一次排序,将最大的9放在最后,第二次排序,将剩下的2 3 5 4 7 6 8进行冒泡,将当前最大的8放在倒数第二的位置,以此类推 接下来上代码 #include &lt;stdio.h&...
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 2804
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 503
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
最新发布
weixin_47868976的博客
10-31 1039
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3855
BSP驱动开发工程师-OS、4 道编程题
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 407
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值