【Week 13 作业】A - TT 的神秘任务1（必做）、B - TT 的神秘任务2（必做）、C - TT 的奖励（必做）、D - TT 的苹果树（选做）、E - TT 的神秘任务3（选做）

最新推荐文章于 2022-05-29 13:51:46 发布

容嬷嬷当年一枝花

最新推荐文章于 2022-05-29 13:51:46 发布

阅读量233

点赞数

本文链接：https://blog.csdn.net/weixin_44898140/article/details/106227605

版权

A - TT 的神秘任务1（必做）

题意：

这一天，TT 遇到了一个神秘人。

神秘人给了两个数字，分别表示 n 和 k，并要求 TT 给出 k 个奇偶性相同的正整数，使得其和等于 n。

例如 n = 10，k = 3，答案可以为 [4 2 4]。

TT 觉得这个任务太简单了，不愿意做，你能帮他完成吗？

本题是SPJ

Input

第一行一个整数 T，表示数据组数，不超过 1000。

之后 T 行，每一行给出两个正整数，分别表示 n（1 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 100）。

Output

如果存在这样 k 个数字，则第一行输出 “YES”，第二行输出 k 个数字。

如果不存在，则输出 “NO”。

Sample Input

8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9

Sample Output

YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120

思路做法：

多种情况分别讨论，会很容易发现奇偶数组合规律

总结:

要把所有情况都考虑到，再造数据来debug

代码:

#include <stdio.h>
int main(){
	int t; scanf("%d", &t);
	while(t--){
		int n, k; scanf("%d%d", &n, &k);
		if(n < k) printf("NO\n");
		else if(n == k){
			printf("YES\n");
			for(int i = 1; i < n; ++i) printf("1 ");
			printf("1\n");
		}else{
			if((n % 2 && k % 2) || (!(n % 2) && !(k % 2))){
				printf("YES\n");
				for(int i = 1; i < k; ++i) printf("1 ");
				printf("%d\n", n-k+1);
			}else if(n % 2 && !(k % 2)){
				printf("NO\n");
			}else{
				if(n <= (k-1)*2) printf("NO\n");
				else{
					printf("YES\n");
					for(int i = 1; i < k; ++i) printf("2 ");
					printf("%d\n", n-(k-1)*2);
				}
				
			}
		}
	}
	return 0;
}

B - TT 的神秘任务2（必做）

题意：

在你们的帮助下，TT 轻松地完成了上一个神秘任务。

但是令人没有想到的是，几天后，TT 再次遇到了那个神秘人。

而这一次，神秘人决定加大难度，并许诺 TT，如果能够完成便给他一个奖励。

任务依旧只给了两个数字，分别表示 n 和 k，不过这一次是要求 TT 给出无法被 n 整除的第 k 大的正整数。

例如 n = 3，k = 7，则前 7 个无法被 n 整除的正整数为 [1 2 4 5 7 8 10]，答案为 10。

好奇的 TT 想要知道奖励究竟是什么，你能帮帮他吗？

Input

第一行一个整数 T，表示数据组数，不超过 1000。

之后 T 行，每一行给出两个正整数，分别表示 n（2 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 1e9）。

Output

对于每一组数据，输出无法被 n 整除的第 k 大的正整数。

Sample Input

6
3 7
4 12
2 1000000000
7 97
1000000000 1000000000
2 1

Sample Output

思路做法：

题意很容易理解，并且很有规律，不用挨个遍历，直接写出公式计算即可

总结:

根据数据验证公式，公式分2种情况

代码:

#include <stdio.h>
int main(){
	int t; scanf("%d", &t);
	while(t--){
		int n, k; scanf("%d%d", &n, &k);
		if(k%(n-1)) printf("%d\n", k/(n-1)*n+k%(n-1));
		else printf("%d\n", k/(n-1)*n+k%(n-1)-1);
	}
	return 0;
}

C - TT 的奖励（必做）

题意：

在大家不辞辛劳的帮助下，TT 顺利地完成了所有的神秘任务。

神秘人很高兴，决定给 TT 一个奖励，即白日做梦之捡猫咪游戏。

捡猫咪游戏是这样的，猫咪从天上往下掉，且只会掉在 [0, 10] 范围内，具体的坐标范围如下图所示。
在这里插入图片描述
TT 初始站在位置五上，且每秒只能在移动不超过一米的范围内接住掉落的猫咪，如果没有接住，猫咪就会跑掉。例如，在刚开始的一秒内，TT 只能接到四、五、六这三个位置其中一个位置的猫咪。

喜爱猫咪的 TT 想要接住尽可能多的猫咪，你能帮帮他吗？

Input

多组样例。每组样例输入一个 m (0 < m < 100000)，表示有 m 只猫咪。

在接下来的 m 行中，每行有两个整数 a b (0 < b < 100000)，表示在第 b 秒的时候有一只猫咪掉落在 a 点上。

注意，同一个点上同一秒可能掉落多只猫咪。m = 0 时输入结束。

Output

输出一个整数 x，表示 TT 可能接住的最多的猫咪数。

Sample Input

Sample Output

思路做法：

用2维矩阵存储猫咪，行为位置，列为时间。对时间迭代，当前时间位置的接住的最大总猫咪数是由前一时间相邻的3个位置里最大的值加上当前时间位置的猫咪数更新来的（注意位置两头略有不同），但是题目还有一个限制，初始位置为5，因此前5次必须把这个条件体现出来，之后相当于动态规划直接找最大数即可。

总结:

初始位置为5作为一个限制会影响前5轮，用数值体现这一限制。

代码:

#include <stdio.h>
#include <algorithm>
using namespace std;
const int N = 1e5+20;
int cat[12][N], old_dp[12], new_dp[12];
int main(){
	int m;
	while(~scanf("%d", &m)){
		if(m == 0) break;
		for(int i = 0; i <= 10; ++i){
			old_dp[i] = 0; new_dp[i] = 0;
			for(int j = 1; j < N; ++j){
				cat[i][j] = 0;
			}
		}
		int t = 0;
		for(int i = 1; i <= m; ++i){
			int a, b; scanf("%d%d", &a, &b);
			cat[a][b]++;
			if(b > t) t = b;
		}
		for(int j = 1; j <= 5 && j <= t; ++j){
			int le = 5 - j, ri = 5 + j;
			new_dp[le] = old_dp[le+1] + cat[le][j];
			new_dp[ri] = old_dp[ri-1] + cat[ri][j];
			for(int i = le+1; i < ri; ++i){
				new_dp[i] = max(old_dp[i-1], max(old_dp[i], old_dp[i+1])) + cat[i][j];
			}
			for(int i = le; i <= ri; ++i) old_dp[i] = new_dp[i];
		} 
		for(int j = 6; j <= t; ++j){
			new_dp[0] = max(old_dp[0], old_dp[1]) + cat[0][j];
			for(int i = 1; i <= 9; ++i){
				new_dp[i] = max(old_dp[i-1], max(old_dp[i], old_dp[i+1])) + cat[i][j];
			}
			new_dp[10] = max(old_dp[9], old_dp[10]) + cat[10][j];
			for(int i = 0; i <= 10; ++i) old_dp[i] = new_dp[i];
		}
		int max = 0;
		for(int i = 0; i <= 10; ++i){
			if(new_dp[i] > max) max = new_dp[i];
		}
		printf("%d\n", max);
	}
	return 0;
}

D - TT 的苹果树（选做）

题意：

在大家的三连助攻下，TT 一举获得了超级多的猫咪，因此决定开一间猫咖，将快乐与大家一同分享。并且在开业的那一天，为了纪念这个日子，TT 在猫咖门口种了一棵苹果树。

一年后，苹果熟了，到了该摘苹果的日子了。

已知树上共有 N 个节点，每个节点对应一个快乐值为 w[i] 的苹果，为了可持续发展，TT 要求摘了某个苹果后，不能摘它父节点处的苹果。

TT 想要令快乐值总和尽可能地大，你们能帮帮他吗？

Input

结点按 1～N 编号。

第一行为 N (1 ≤ N ≤ 6000) ，代表结点个数。

接下来 N 行分别代表每个结点上苹果的快乐值 w[i]（-128 ≤ w[i] ≤ 127)。

接下来 N-1 行，每行两个数 L K，代表 K 是 L 的一个父节点。

输入有多组，以 0 0 结束。

Output

每组数据输出一个整数，代表所选苹果快乐值总和的最大值。

Sample Input

Sample Output

思路做法：

树状DP
定义dp状态为 $d p [i] [2]$ ，其中 $d p [i] [0]$ 表示以 $i$ 为根的子树且未选择 $i$ ， $d p [i] [1]$ 表示以 $i$ 为根的子树且选择 $i$ （这样的话子节点自然不能选择）。因此状态转换为 $\Sigma max(dp[j][0], dp[j][1])$ ， $\Sigma dp[j][0]$ 其中 $j$ 为 $i$ 的子节点。这个也好理解，当前子树的根若为选中，则遍历其子节点，子节点没有限制，取选与不选2个状态的最大值累加，而根若选中，则子节点必不能选，因此遍历后取不选的状态累加，并在最后还要加上根节点的数值。
树状DP用dfs遍历整棵树。

总结:

不一定要找到根节点再dfs，将所有结点遍历一遍，采取vis数组的形式判断是否可以直接采用计算出的数值（类似于记忆化），并将答案不断更新即可。

代码:

#include <stdio.h>
#include <vector>
#define max(x, y) x>y?x:y
using namespace std;
const int N = 6e3+20;
int w[N], vis[N], dp[N][2], n;
vector<int> g[N];
void dfs(int v) {
	vis[v] = 1;
	for(int i = 0; i < g[v].size(); ++i) {
		int u = g[v][i];
		if(vis[u] == 0) dfs(u);
		dp[v][0] += max(dp[u][0], dp[u][1]);
		dp[v][1] += dp[u][0];
	}
	dp[v][1] += w[v];
}
int main(){
	while(~scanf("%d%d", &n, &w[1])){
		if(n == 0 && w[1] == 0) break;
		for(int i = 2; i <= n; ++i) scanf("%d", &w[i]);
		for(int i = 1; i < n; ++i){
			vis[i] = 0; dp[i][0] = 0; dp[i][1] = 0;
			int l, k; scanf("%d%d", &l, &k);
			g[k].push_back(l);
		}
		int ans = 0;
		for(int i = 1; i <= n; ++i) {
			if(vis[i] == 0) dfs(i);
			int tmp = max(dp[i][0], dp[i][1]);
			ans = max(ans, tmp);
		}
		printf("%d\n", ans);
	}
	return 0;
}

E - TT 的神秘任务3（选做）

题意：

TT 猫咖的生意越来越红火，人越来越多，也越来越拥挤。

为了解决这个问题，TT 决定扩大营业规模，但猫从哪里来呢？

TT 第一时间想到了神秘人，想要再次通过完成任务的方式获得猫咪。

而这一次，神秘人决定加大难度。

给定一个环，A[1], A[2], A[3], … , A[n]，其中 A[1] 的左边是 A[n]。要求从环上找出一段长度不超过 K 的连续序列，使其和最大。

这一次，TT 陷入了沉思，他需要你们的帮助。

Input

第一行一个整数 T，表示数据组数，不超过 100。

每组数据第一行给定两个整数 N K。（1 ≤ N ≤ 100000, 1 ≤ K ≤ N）

接下来一行，给出 N 个整数。（-1000 ≤ A[i] ≤ 1000）。

Output

对于每一组数据，输出满足条件的最大连续和以及起始位置和终止位置。

如果有多个结果，输出起始位置最小的，如果还是有多组结果，输出长度最短的。

Sample Input

4
6 3
6 -1 2 -6 5 -5
6 4
6 -1 2 -6 5 -5
6 3
-1 2 -6 5 -5 6
6 6
-1 -1 -1 -1 -1 -1

Sample Output

思路做法：

动态规划加单调队列优化复杂度
单纯的动态规划为dp[i] = max(dp[i], dp[i-j]) 其中j取1到k，但这样的复杂度为O(nk)
通过单调队列可以将复杂度降至O(n)，具体做法是从左到右遍历一遍，dp[i] = max(dp[i], sum[i] - min(sum[i- j]))，其中的min[sum[i-j]]可以用单调队列维护，这样遍历完即可得到答案
由于题目涉及环，因此变环为链。

总结:

之前的类似的单调队列代码没有在循环前加q[++end] = 0，这次完善了。

代码:

#include <stdio.h>
#define max(x, y) x>y?x:y
const int N = 1e5+20;
const int inf = 1e8;
int a[2 * N], sum[2 * N], q[2 * N];
int main() {
	int t; scanf("%d", &t);
	while(t--) {
		int n, k; scanf("%d%d", &n, &k);
		for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
		for(int i = 1; i <= k; ++i) a[n + i] = a[i];  // 变环为链
		sum[0] = 0;
		for(int i = 1; i <= n + k; ++i) sum[i] = sum[i - 1] + a[i];  // 前缀和
		int start = 0, end = 0, le = 0, ri = 0, ans = -inf;
		q[++end] = 0;
		for(int i = 1; i < n + k; ++i) {
			while(start < end && q[start + 1] < i - k) start++;
			while(start < end && sum[q[end]] > sum[i]) end--;  // 递增队列，队列首始终是最小值
			q[++end] = i;
			if(end - start > 1) {
				if(sum[i] - sum[q[start + 1]] > ans) {
					ans = sum[i] - sum[q[start + 1]];
					le = q[start + 1] + 1; ri = i;
				}
			} else if(end - start == 1) {  // 只有它自己 
				if(sum[i] - sum[i - 1] > ans) {
					ans = sum[i] - sum[i - 1];
					le = i; ri = i;
				}
			}
		}
		printf("%d %d %d\n", ans, le, ri > n ? ri-n : ri);
	}
	return 0;
}

容嬷嬷当年一枝花

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Week 13 作业】A - TT 的神秘任务1（必做）、B - TT 的神秘任务2（必做）、C - TT 的奖励（必做）、D - TT 的苹果树（选做）、E - TT 的神秘任务3（选做）

A - TT 的神秘任务1（必做）题意：这一天，TT 遇到了一个神秘人。神秘人给了两个数字，分别表示 n 和 k，并要求 TT 给出 k 个奇偶性相同的正整数，使得其和等于 n。例如 n = 10，k = 3，答案可以为 [4 2 4]。TT 觉得这个任务太简单了，不愿意做，你能帮他完成吗？本题是SPJInput第一行一个整数 T，表示数据组数，不超过 1000。之后 T 行，每一行给出两个正整数，分别表示 n（1 ≤ n ≤ 1e9）、k（1 ≤ k ≤ 100）。Output如果存
复制链接

扫一扫