算法设计第二次测试题

A - 数字三角形

分析：设f[i][j]表示到第i行第j个位置所能到达的最大值，可以自下往上更新也可以自上往下遍历，我在这里采用的是自下往上遍历的，一开始把f[n][i]=a[n][i]，也就是把最底层的f数组赋初值，然后利用f[i][j]=max(f[i+1][j],f[i+1][j+1])+a[i][j]进行更新即可。最后结果就存在于f[1][1]中

下面是代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
using namespace std;
const int N=1003;
int f[N][N],a[N][N];
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			scanf("%d",&a[i][j]);
	for(int i=1;i<=n;i++)
		f[n][i]=a[n][i];
	for(int i=n-1;i>=1;i--)
	for(int j=1;j<=i;j++)
		f[i][j]=max(f[i+1][j],f[i+1][j+1])+a[i][j];
	cout<<f[1][1];
	return 0;
}

B - 公共子序列

（POJ - 1458）Common Subsequence（最长公共子序列）_AC__dream的博客-CSDN博客

C - 回文子串

回文子串（区间动态规划）_AC__dream的博客-CSDN博客

D - 括号问题

题目链接：22算法设计与分析-动态规划 - Virtual Judge

分析：典型的区间问题，设f[i][j]表示从i~j的括号可匹配的最大长度，然后我们遍历区间时讨论区间左右端点，如果s[i]==s[j]，那么f[i][j]=f[i+1][j-1]+2,在i+1~j-1的最大括号匹配长度上加上当前左右端点的两个可匹配的括号，如果不满足就直接进行分断点讨论最大值即可。

下面是代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
using namespace std;
const int N=5e2+10;
int f[N][N];
int main()
{
	string s;
	while(cin>>s)
	{
		if(s[0]=='e') break;
		memset(f,0,sizeof f);
		int l=s.length();
		for(int len=2;len<=l;len++)
		for(int i=0;i+len-1<l;i++)
		{
			int j=i+len-1;
			if((s[i]=='('&&s[j]==')')||(s[i]=='['&&s[j]==']')) f[i][j]=f[i+1][j-1]+2;
			for(int k=i;k<j;k++)
				f[i][j]=max(f[i][j],f[i][k]+f[k+1][j]);
		}
		printf("%d\n",f[0][l-1]);
	}
	return 0;
}

E - 合并石子

P1880 [NOI1995] 石子合并（区间DP+思维）_AC__dream的博客-CSDN博客

F - 干草出售

题目链接：22算法设计与分析-动态规划 - Virtual Judge

这就是一个基本的01背包问题，直接放代码了

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
#include<map>
#include<cmath>
#include<queue>
using namespace std;
const int N=5e4+10;
int f[N],v[N];
int main()
{
	int V,n;
	cin>>V>>n;
	for(int i=1;i<=n;i++)
		scanf("%d",&v[i]);
	for(int i=1;i<=n;i++)
	for(int j=V;j>=v[i];j--)
		f[j]=max(f[j],f[j-v[i]]+v[i]);
	printf("%d",f[V]);
	return 0;
}

G - 最爱递归

题目链接：22算法设计与分析-动态规划 - Virtual Judge

这个不建议用记忆化搜索来解决，因为用记忆化搜索时一但解决不好边界问题就会超时，可以直接按照题目中所给的条件进行动态转移，因为完全是按照题目中给定的方式转移的，所以就直接放代码了

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N=55;
long long dp[N][N][N];
int main()
{
	long long a,b,c;
	for(int i=0;i<=20;i++)
	for(int j=0;j<=20;j++)
	for(int k=0;k<=20;k++)
	{
		if(i==0||j==0||k==0)
			dp[i][j][k]=1;
		else if(i<j&&j<k)
			dp[i][j][k]=dp[i][j][k-1]+dp[i][j-1][k-1]-dp[i][j-1][k];
		else 
			dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k]+dp[i-1][j][k-1]-dp[i-1][j-1][k-1];	
	}
	while(1)
	{
		scanf("%lld%lld%lld",&a,&b,&c);
		if(a==-1&&b==-1&&c==-1) return 0;
		if(a<=0||b<=0||c<=0)
		printf("w(%lld, %lld, %lld) = 1\n",a,b,c);
		else if(a>20||b>20||c>20)
		printf("w(%lld, %lld, %lld) = %lld\n",a,b,c,dp[20][20][20]); 
		else
		printf("w(%lld, %lld, %lld) = %lld\n",a,b,c,dp[a][b][c]);
	}
	return 0;
}