SDU程序设计思维Week13-作业树型DP/单调队列DP

最新推荐文章于 2022-07-12 00:00:00 发布

Scott Yang

最新推荐文章于 2022-07-12 00:00:00 发布

阅读量233

点赞数

文章标签：动态规划程序设计

本文链接：https://blog.csdn.net/weixin_44578615/article/details/106120442

版权

SDU程序设计思维Week13-作业

A - TT 的神秘任务1

Description

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

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

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

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

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

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

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

如果不存在，则输出 "NO"。

Sample


    Input

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

    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

（答案多解）

Idea

题意：找到k个同是奇数或同是偶数的数之和等于n

可知，任何奇数可由1累加而得，任何偶数可由2累加而得。
因此取前k-1个数为1，第k个数如果为奇数，同时满足n-(k-1)>0，则YES,得到正确答案
取前k-1个数为2，第k个数如果为偶数，同时满足n-2*(k-1)>0，则YES,得到正确答案

Summary

这题不难，关键是想到奇数都可由1组合，偶数由2组合。

Codes

#include <iostream>

using namespace std;
long long n, k,T;

int main()
{
	cin >> T;
	while (T--) {
		cin >> n >> k;
		
		if ((n - k + 1) % 2 == 1 && n - k + 1 > 0) {
			printf("YES\n");
			for (int i = 1; i <= k - 1; i++)
				printf("1 ");
			cout << n - k + 1 << endl;
			
		}
		else if ((n - 2 * k + 2) % 2 == 0 && n - 2 * k + 2 > 0) {
			printf("YES\n");
			for (int i = 1; i <= k - 1; i++)
				printf("2 ");
			cout << n - 2 * k + 2 << endl;

		}
		else printf("NO\n");

	}
}

B - TT 的神秘任务2

Description

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

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

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

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

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

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

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

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

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

Sample


    Input

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

    Output

    10
    15
    1999999999
    113
    1000000001
    1

Idea

题意：找到第k个不能被n整除的数

从1开始分组，每组n-1个数，跳过n的倍数的数，找出第k个不能被n整除的数对应的分组，根据分组获得其序号即值，例如n=3,k=7中，12_3_45_6_78_9_1011_12，n*k/(n-1)=10,10%3!=0，所以ans=10（第四组的第一个）

Summary

这题将不能被n整除的数分组，求得第k个不能被n整除的数所在组。注意数据范围，要用long long。

Codes

#include <iostream>

using namespace std;
long long T, n, k;

int main()
{
	cin >> T;
	while (T--)
	{
		cin >> n >> k;
		long long tmp = n * k / (n - 1);
		if (tmp%n == 0)cout << tmp - 1 << endl;
		else cout << tmp << endl;

	}
}

C - TT 的奖励

Description

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

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

捡猫咪游戏是这样的，猫咪从天上往下掉，且只会掉在 [0, 10] 范围内，具体的坐标范围如下图所示。

TT 初始站在位置五上，且每秒只能在移动不超过一米的范围内接住掉落的猫咪，如果没有接住，猫咪就会跑掉。例如，在刚开始的一秒内，TT 只能接到四、五、六这三个位置其中一个位置的猫咪。

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

在这里插入图片描述

多组样例。每组样例输入一个 m (0 < m < 100000)，表示有 m 只猫咪。
在接下来的 m 行中，每行有两个整数 a b (0 < b < 100000)，表示在第 b 秒的时候有一只猫咪掉落在 a 点上。
注意，同一个点上同一秒可能掉落多只猫咪。m = 0 时输入结束。

Sample

Input:
6
5 1
4 1
6 1
7 2
7 2
8 3
0
Output:
4

Idea

动态规划

定义状态f[b][a]表示在第b秒在a点接到的猫咪数量
初始化f[b][a]，输入m行数据，表示开始之前，f[b][a]记录了在第b秒掉落在a点的猫咪数量
遍历每个时刻下的每个位置，从最后一只猫咪掉落的时刻开始向第0秒遍历
状态转移方程：f[i][j] = f[i][j] + max(f[i + 1][j - 1], max(f[i + 1][j], f[i + 1][j + 1]))
max取后一时刻周围三个位置各自能接到猫咪数量的最大值

Summary

这题是动态规划的应用，初始位置pos已定，因此从最后时刻向0时刻遍历，答案取f[0][pos]即可

Codes

#include <iostream>
#include <algorithm>
using namespace std;
int m;
int a, b,f[100020][15],t;

int main()
{
	while (cin >> m) {
		if (m == 0)break;
		t = 0;
		memset(f, 0, sizeof(f));
		for (int i = 1; i <= m; i++)
		{
			cin >> a >> b;
			f[b][a]++;
			if (b > t)t = b;
		}

		for (int i = t - 1; i >= 0; i--)
			for (int j = 0; j <= 10; j++)
				f[i][j] += max(f[i + 1][j - 1], max(f[i + 1][j], f[i + 1][j + 1]));
		cout << f[0][5] << endl;

	}
}

D - TT 的苹果树

Description

已知树上共有 N 个节点，每个节点对应一个快乐值为 w[i] 的苹果，为了可持续发展，TT 要求摘了某个苹果后，不能摘它父节点处的苹果。
TT 想要令快乐值总和尽可能地大，你们能帮帮他吗？

结点按 1～N 编号。

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

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

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

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

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

Sample

Input:
7
1
1
1
1
1
1
1
1 3
7 4
2 3
4 5
6 4
3 5
0 0
Output:
5

Idea

题意：有一棵树每个节点有一定快乐值，取树上若干个节点欲获得最大快乐值，要求选了某个节点就不能选择它的父节点。

初始化
获得每个节点的初始快乐值
用前向星存储每条父节点指向子节点的边
根据这n-1条边找出整棵树的根节点
定义状态f[i][0/1]表示以 i 为节点的子树所能得到的最大的快乐值
f[i][0]表示以i为子树且未选择i号节点
f[i][1]表示以i为子树且选择了i号节点
最终答案即max(f[root][0],f[root][1])
状态转移方程：f[i][0]=∑max(f[x][1],f[x][0]) f[i][1]=ai+∑f[x][0] x表示i可直接到达的子节点
DFS
使用DFS从根节点出发搜索整个树，完成自下而上的状态转移

Summary

这题是动态规划+DFS，对于以每个节点为子树需分别计算选择该节点和不选择它两种情况下的所能得到的最大快乐值，要注意数据的初始化

Codes

#include <iostream>
#include <algorithm>

using namespace std;
int n, tot = 0, l, k, root;
int head[6020], w[6020], f[6020][3];
bool vis[6020] = { true };
struct edge {
	int u, v, next;
}e[6020];

void add(int u, int v) {
	tot++;
	e[tot].u = u;
	e[tot].v = v;
	e[tot].next = head[u];
	head[u] = tot;
}

void init(int n) {
	tot = 0;
	for (int i = 1; i <= n; i++) {
		head[i] = 0;
		vis[i] = true;
	}
	memset(f, 0, sizeof(f));

}

void dfs(int u) {
	f[u][1] = w[u];
	for (int i = head[u]; i != 0; i = e[i].next) {
		int v = e[i].v;
		dfs(v);
		f[u][0] += max(f[v][1], f[v][0]);
		f[u][1] += f[v][0];

	}
}



int main()
{
	while (cin >> n) {
		
		if (n == 0)break;
		init(n);

		for (int i = 1; i <= n; i++)
			cin >> w[i];

		for (int i = 1; i <= n - 1; i++) {
			cin >> l >> k;
			add(k, l);
			vis[l] = false;

		}
		for (int i = 1; i <= n; i++)
			if (vis[i])root = i;

		dfs(root);
		cout << max(f[root][0], f[root][1]) << endl;

	}


}

E - TT 的神秘任务3

Description

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

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

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

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

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

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

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

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
Output:
7 1 3
7 1 3
7 6 2
-1 1 1

Idea

题意：取环中一段长度不超过k的连续序列，其和最大

初始化
化环为链，将环拆成一条链，链长为n+k-1
初始化每个点到起点的序列和sum
状态转移方程ans=max(ans,sum[i]-min{sum[m]})（i-k<=m<=i）
滑动窗口
利用滑动窗口维护一个长度不超过k的sum单调递增序列，则min{sum[m]}就是队列的最左端
根据规则更新ans
如果有多个结果，输出起始位置最小的，如果还是有多组结果，输出长度最短的。

Summary

这题是动态规划+滑动窗口
注意数据范围大，这题要用scanf，不然会超时
最后左右边界要记得对n求余

Codes

#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;
int T, n, k;
int a[200100], sum[200100];

int main()
{

	cin >> T;
	while (T--) {
		scanf("%d%d", &n, &k);
		memset(a, 0, sizeof(a));
		memset(sum, 0, sizeof(sum));
		for (int i = 1; i <= n; i++)
		{
			scanf("%d", a + i);
			a[i + n] = a[i];
		}
		deque<int> q;
		
		for (int i = 1; i <= n + k - 1; i++)sum[i] = sum[i - 1] + a[i];
		long long l = 0, r = 1, ans = sum[1];
		q.push_back(0);

		for (int i = 1; i <= n + k - 1; i++) {

			while (!q.empty() && i-k>q.front())
				q.pop_front();
			long long t = sum[i] - sum[q.front()];
			if (t > ans) {
				ans = t;
				l = q.front();
				r = i;
			}
			else if (t == ans) {
				if (q.front()< l) {
					l = q.front();
					r = i;
				}
				else if (q.front() == l) {
					if (r - l + 1 > i - q.front() + 1)l = q.front(), r = i;
				}
			}
			while (!q.empty() && sum[q.back()] > sum[i])q.pop_back();
			q.push_back(i);

		}
		l++;
		if (l > n)l = l % n;
		if (r > n)r = r % n;
		printf("%lld %lld %lld\n", ans, l, r);

	}
}