ACM算法基础训练之动态规划

chong墩儿

已于 2022-05-25 10:53:56 修改

阅读量984

点赞数 1

分类专栏： ACM 二级C 文章标签：算法动态规划深度优先 ACM c语言

于 2022-03-01 09:27:03 首次发布

本文链接：https://blog.csdn.net/qq_42244418/article/details/123191835

版权

ACM 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

二级C

2 篇文章 0 订阅

订阅专栏

动态规划基础题目

A 最大子串和

题目描述
给定一整型数列{a1,a2…,an}，找出连续非空子串{ax,ax+1,…,ay}，使得该子序列的和最大，其中，1<=x<=y<=n。
输入
第一行是一个整数N(N<=10)表示测试数据的组数）
每组测试数据的第一行是一个整数n表示序列中共有n个整数，随后的一行里有n个整数I(-100=<I<=100)，表示数列中的所有元素。
输出
对于每组测试数据输出和最大的连续子串的和。
Sample Input
2
5
1 2 -3 4 -1
5
1 2 -1 3 -2
Sample Output
4
5

#include<bits/stdc++.h>
using namespace std;
int main()
{
   int T;
   cin>>T;
   while(T--){
   	int n,a[1005],sum[1005]={0};
   	int max_sum=-500;
   	cin>>n;
   	// sum为前i项的子串和 
   	for(int i=0;i<n;i++){
   		cin>>a[i];
   		sum[i+1]=sum[i]+a[i];
   	}
   	// 找到区间最大和 
   	for(int i=1;i<=n;i++){
   		for(int j=0;j<i;j++){
   			max_sum=max(max(sum[i],sum[i]-sum[j]),max_sum);
   		}
   	}
   	cout<<max_sum<<endl;
   } 
   return 0;
}

B 最大的算式

题目描述
题目很简单，给出N个数字，不改变它们的相对位置，在中间加入K个乘号和N-K-1个加号，（括号随便加）使最终结果尽量大。因为乘号和加号一共就是N-1个了，所以恰好每两个相邻数字之间都有一个符号。例如：
N=5，K=2，5个数字分别为1、2、3、4、5，可以加成：
12(3+4+5)=24
1*(2+3)(4+5)=45
(12+3)*(4+5)=45
……
输入
多组文件测试，每组输入文件共有二行，第一行为两个有空格隔开的整数，表示N和K，其中（2<=N<=15, 0<=K<=N-1）。第二行为 N个用空格隔开的数字（每个数字在0到9之间）。
输出
每个输出文件仅一行包含一个整数，表示要求的最大的结果。
Sample Input
5 2
1 2 3 4 5
Sample Output
120
tips
(1+2+3)4*5=120

#include<iostream>
#include<cstring>
using namespace std;
long long int dp[16][16];
int sum[16];
int main()
{
	int n,k;
	while(cin>>n>>k)
	{
		memset(sum,0,sizeof(sum));
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=n;i++)
		{
			int temp;
			cin>>temp;
			sum[i]=sum[i-1]+temp;
		}
		for(int i=1;i<=n;i++)
		dp[i][0]=sum[i];
		for(int i=2;i<=n;i++)
		{
			for(int j=1;j<=i-1&&j<=k;j++)
				for(int m=2;m<=i;m++)
					dp[i][j]=max(dp[i][j],dp[m-1][j-1]*(sum[i]-sum[m-1]));
		}
		cout<<dp[n][k]<<endl;	
	}
	return 0;
}

C 最长公共字符串

题目描述
给你两个字符串，你需要做的是找出两个字符串中最长的公共字符串（不需要连续，例如：context nant的公共字符串为nt）。
输入
多组数据测试，每组数据占一行，两个字符串用空格隔开。
输出
输出最长的公共字符串长度
Sample Input
context nant
programming context
abcdefg bacfe
Sample Output
2
2
3

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int dp[100][100];
	char a[100],b[100];
	while(~scanf("%s %s",a+1,b+1))
	{
		int l1,l2;
		l1=strlen(a+1);
		l2=strlen(b+1);
		memset(dp,0,sizeof(dp));
		for(int i=1;a[i];i++)
		{
			for(int j=1;b[j];j++)
			{
				if(a[i]==b[j])
				dp[i][j]=dp[i-1][j-1]+1;
				else
				{
					dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
				}
			}
		}
		cout<<dp[l1][l2]<<endl;
	}
	return 0;
}

D 最长递增子序列

题目描述
给你一个正整数序列，要求求出其中的最大递增子序列长度。(例如：1 3 4 9 8 5 7 6 10的最大递增子序列为:1 3 4 5 6 10或1 3 4 5 7 10)
输入
多组数据测试，每组数据第一行输入一个数n，代表要求n个正整数的最大子序列。
接下来一行输入n个正整数，代表需要求最大子序列长度的正整数序列。
输出
每组测试数据输出一行，代表最大递增子序列长度。
Sample Input
9
1 3 4 9 8 5 7 6 10
Sample Output
6

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int dp[1005];
	int a[1005];
	int n;
	while(cin>>n){
		int i,j;
		for(i=1;i<=n;i++){
			cin>>a[i];
		}
		int t=0;
		for(i=1;i<=n;i++){
			dp[i]=1;
			for(j=1;j<i;j++){
				if(a[j]<a[i]){
					dp[i]=max(dp[i],dp[j]+1);
				}
			} 
			t=max(t,dp[i]); 
		}
		cout<<t<<endl;
	}
	return 0;
}

E 最大子阵

题目描述
给定一个n*m的矩阵A，求A中的一个非空子矩阵，使这个子矩阵中的元素和最大。
其中，A的子矩阵指在A中行和列均连续的一块。
输入
输入的第一行包含两个整数n, m，分别表示矩阵A的行数和列数。
接下来n行，每行m个整数，表示矩阵A。
对于50%的数据，1<=n, m<=50；
对于100%的数据，1<=n, m<=500，A中每个元素的绝对值不超过5000。
输出
输出一行，包含一个整数，表示A中最大的子矩阵中的元素和。
Sample Input
3 3
-1 -4 3
3 4 -1
-5 -2 8
Sample Output
10

#include<bits/stdc++.h>
using namespace std;
const int minn=-999999;
int a[1005][1005],b[1005],dp[1005];
int main()
{
	int m,n;
	while(cin>>n>>m){
		memset(a,0,sizeof(a));
		memset(dp,0,sizeof(dp));
		int maxn=minn;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				cin>>a[i][j];
			}
		}
		for(int x=1;x<=n;x++){
			memset(b,0,sizeof(b));
			for(int y=x;y<=n;y++){
				for(int j=1;j<=m;j++){
					b[j]+=a[y][j];
				}
				dp[0]=0;
				dp[1]=b[1];
				if(dp[1]>maxn)maxn=dp[1];
				for(int i=2;i<=m;i++){
					if(dp[i-1]<0){
						dp[i]=b[i];
					}
					else dp[i]=dp[i-1]+b[i];
					maxn=max(maxn,dp[i]);
				} 
			}
		}
		cout<<maxn<<endl;
	}
	return 0;	
}

F 最大的数

题目描述
在一个ab的矩阵中（1<a,b<9，ab<=22）每一个方格里面有着1~9的任意一个数字或者#（代表障碍），你可以从矩阵中的任意一个格子出发（当然不能从#里出发），然后每次沿着上下左右之一的方向走一格，但不能走到障碍格中，也不能重复经过一个数字格，把所走过的数（如图可以构成9784，4879等）连接起来，问能够得到的最大整数是多少？
输入
有多组输入数据，第一行输入a,b代表行列，然后接下来a行每行输入b个数字或者#，含义如上面描述，当a，b同时为0时程序结束。
输出
输出最大的数。
Sample Input
3 7
##9784#
##123##
##45###
Sample Output
791452384

#include<bits/stdc++.h>
using namespace std;
int a[4]={0,1,0,-1};
int b[4]={1,0,-1,0};
char c[10][10];
int t[10][10];
int w,h;
long long sum;
void dfs(int x,int y,long long k){
	sum=max(sum,k);
	for(int i=0;i<4;i++){
		if(c[x+a[i]][y+b[i]]!='#'&&x+a[i]>=0&&x+a[i]<h&&y+b[i]>=0&&y+b[i]<w&&t[x+a[i]][y+b[i]]!=1){
			t[x][y]=1;
			dfs(x+a[i],y+b[i],k*10+c[x+a[i]][y+b[i]]-'0');
			t[x][y]=0;
		}
	}
}
int main()
{
	while(cin>>h>>w){
		if(h==0&&w==0)break;
		sum=0;
		for(int i=0;i<h;i++){
			for(int j=0;j<w;j++){
				cin>>c[i][j];
			}
		}
		for(int i=0;i<h;i++){
			for(int j=0;j<w;j++){
				if(c[i][j]!='#'){
					memset(t,0,sizeof(t));
					dfs(i,j,c[i][j]-'0');
				}
			}
		}
		cout<<sum<<endl;
	}
	return 0;
}