算法刷题记录(Day 60)

最新推荐文章于 2024-09-27 11:17:47 发布

fumingxiaoshen

最新推荐文章于 2024-09-27 11:17:47 发布

阅读量146

点赞数 1

分类专栏：算法刷题记录文章标签：算法动态规划 c++

本文链接：https://blog.csdn.net/fumingxiaoshen/article/details/124923296

版权

算法刷题记录专栏收录该内容

78 篇文章 1 订阅

订阅专栏

本文解析了复旦大学计算机科学学院2019年机考中的三道题目：天数计算方法、利用动态规划解决最大连续子序列问题，以及通过递推公式探讨二叉树形态的计数。通过实例演示和关键算法，帮助理解并解答这些计算机科学基础题目的解法。

摘要由CSDN通过智能技术生成

复旦计算机院2019机考

第一题天数计算

在这里插入图片描述

//测试样例
In:20190208
Out:3

In:20890718
Out:25731

#include <iostream>
using namespace std;
int year=0, month=0, day=0;
char c;
int days1[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
int days2[13] = { 0,31,29,31,30,31,30,31,31,30,31,30,31 };
int isleap(int x) {
	if ((x % 4 == 0 && x % 100 != 0) || x % 400 == 0) return 1;
	return 0;
}
void read() {
	for (int i = 0; i < 4; i++) {
		c = getchar();
		year = year * 10 + c - '0';
	}
	for (int i = 0; i < 2; i++) {
		c = getchar();
		month = month * 10 + c - '0';
	}
	for (int i = 0; i < 2; i++) {
		c = getchar();
		day = day * 10 + c - '0';
	}
}
int ca(int y, int m, int d) {
	//离2019年1月1日的天数
	int res = 0;
	for (int i = 2019; i < y; i++) {
		if (isleap(i)) res += 366;
		else res += 365;//注意不是355
	}
	int* day;
	if (isleap(y))day = days2;
	else day = days1;

	for (int i = 1; i < m; i++) {
		res += day[i];
	}
	res += d;
	return res;
}
int main() {
	read();
	int d1 = ca(2019, 2, 5);
	int d2 = ca(year, month, day);
	cout << d2 - d1 << endl;
}

tip:
1.闰年是满足以下两个条件之一的年份:(1)能被4整除但不能被100整除(2)能被400整除
2.非闰年的天数为365而不是355，注意不要笔误。

第二题最大连续子序列

在这里插入图片描述
解题思路:动态规划，注意题目要求的是连续的最大子序列
注:以下所有的区间都表示左闭右开区间，所以最终的结果y应该为整个数字序列的长度
预处理sum[x][y]代表的是区间[x,y)和
维护三个dp数组，dp1[x][y]代表的是x到y的最大的序列和，dp2[x][y]代表的是x到y的且起点是x的最大子序列的和，dp3[x][y]代表的是x到y且终点一定是y的最大子序列的和。

dp1[x][y]=max(dp1[x][k],dp1[k][y],dp3[x][k]+dp2[k][y]);
dp2[x][y]=max(dp2[x][k],sum[x][k]+dp2[k][y])
dp3[x][y]=max(dp3[k][y],dp3[x][k]+sum[k][y])

初始化所有的dp数组为0。在遍历的过程中，k的范围应为[x,y]（初始值为0，可以通过max来过滤）

#include<iostream>
using namespace std;
#define NMAX 1000
int n;
int A[NMAX], dp[3][NMAX][NMAX], sum[NMAX][NMAX];
int main() {
	int n;
	cin >> n;
	memset(dp, 0, sizeof(dp));
	memset(sum, 0, sizeof(sum));
	for (int i = 0; i < n; i++) {
		cin >> A[i];
		sum[i][i + 1] = A[i];
		dp[0][i][i + 1] = dp[1][i][i + 1] = dp[2][i][i + 1] = A[i];
	}

	for (int i = 0; i < n; i++) {
		for (int j = i + 1; j < n; j++) {
			sum[i][j + 1] = sum[i][j] + A[j];
		}

	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j <= n; j++) cout << sum[i][j] << " ";
		cout << endl;
	}
	for (int len = 2; len <= n; len++) {
		for (int x = 0; x < n; x++) {
			int y = x + len;
			if (y > n) break;
			for (int k = x+1; k < y; k++) { //当k等于y的时候dp[2][x][k]和dp[1][k][y]已经被赋值了
				dp[0][x][y] = max(dp[2][x][k] + dp[1][k][y], max(dp[0][x][k], dp[0][k][y])); //这里无法将dp[0][x][x+1]进行正确的赋值
				dp[1][x][y] = max(dp[1][x][k], sum[x][k] + dp[1][k][y]);
				dp[2][x][y] = max(dp[2][k][y], sum[k][y] + dp[2][x][k]);
			}
			printf("[%d %d) %d %d %d\n", x, y, dp[0][x][y], dp[1][x][y], dp[2][x][y]);
		}

	}
	
	cout << dp[0][0][n] << endl;
}

为什么答案是20呢，不应该是24吗？？？这个思路的dp过程中应该是使用了贪心的策略，但是以a[i]为结尾的最大的和前面不一定是以a[i-1]为结尾的最大和。
在这里插入图片描述

第三题二叉树的形态

在这里插入图片描述
解题思路:动态规划，使用dp[i]代表节点为i时所含有二叉树的个数，则有如下所示的递推公式。
dp[i]=sum(dp[k]*dp[i-k-1]) k=0,1,2…i-1
卡特兰数

#include<iostream>
using namespace std;
#define NMAX 10000
int n;
long long dp[NMAX];
int main() {
	cin >> n;
	memset(dp, 0, sizeof(0));
	dp[0] = 1;
	for (int i = 1; i <= n; i++) {
		for (int k = 0; k < i; k++) {
			dp[i] += (dp[k] * dp[i - 1 - k]);
		}
	}
	cout << dp[n];
}