AtCoder Beginner Contest 325题解（A~G） abc325

最新推荐文章于 2024-08-18 19:23:29 发布

Fr1nGeLove

最新推荐文章于 2024-08-18 19:23:29 发布

阅读量300

点赞数

文章标签：数据结构算法

本文链接：https://blog.csdn.net/Fr1nGeLove/article/details/134220673

版权

AtCoder Beginner Contest 325

A - Takahashi san

阅读理解。

时间复杂度 $O (1)$

#include <bits/stdc++.h>

using i64 = long long;

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	std::string s, t;
	std::cin >> s >> t;

	std::cout << s << " san\n";

	return 0;
}

B - World Meeting

由于开始时间只有 $\to 23$ 小时，所以只要枚举这24小时就好了，然后每次统计一下贡献取个最大值。

时间复杂度 $O (24 n)$

#include <bits/stdc++.h>

using i64 = long long;

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int n;
	std::cin >> n;

	std::vector<int> w(n), x(n);
	for (int i = 0; i < n; i++) {
		std::cin >> w[i] >> x[i];
	}

	int ans = 0;
	for (int i = 0; i <= 23; i++) {
		int res = 0;
		for (int j = 0; j < n; j++) {
			int t = (x[j] + i) % 24;
			if (t >= 9 && t < 18) {
				res += w[j];
			}
		}

		// std::cerr << i << " " << res << "\n";
		ans = std::max(ans, res);
	}

	std::cout << ans << "\n";
	return 0;	
}

C - Sensors

实际上就是求连通块

时间复杂度 $O (n)$

#include <bits/stdc++.h>

using i64 = long long;

constexpr int dx[] = {0, -1, -1, -1, 0, 1, 1, 1}, dy[] = {-1, -1, 0, 1, 1, 1, 0, -1};
int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int H, W;
	std::cin >> H >> W;

	std::vector<std::string> S(H);
	for (int i = 0; i < H; i++) {
		std::cin >> S[i];
	}

	std::vector vis(H, std::vector<bool>(W));
	auto dfs = [&](auto self, int x, int y) -> void {
		vis[x][y] = true;

		for (auto dx : {-1, 0, 1}) {
			for (auto dy : {-1, 0, 1}) {
				int nx = x + dx, ny = y + dy;
				if (nx < 0 || nx >= H || ny < 0 || ny >= W || S[nx][ny] != '#') {
					continue;
				}
				if (!vis[nx][ny]) {
					self(self, nx, ny);
				}
			}
		}
	};
	int ans = 0;
	for (int i = 0; i < H; i++) {
		for (int j = 0; j < W; j++) {
			if (!vis[i][j] && S[i][j] == '#') {
				ans++;
				dfs(dfs, i, j);
			}
		}
	}

	std::cout << ans << "\n";
	return 0;	
}

D - Printing Machine

题目的模型实际上就是将每个物品放置在规定的 $x_i \to x_i + y_i$ 之间的格子里，然后每个格子只能放置一个物品，那么结束时间早的物品先放一定要优于结束晚的物品先放，但是如果说直接去枚举时间一定是会超时的，因此我们考虑从哪一方面进行优化。

以开始时间为第一关键字、结束时间为第二关键字排序，用优先队列存储结束时间，每次弹出结束时间最早且大于等于当前时间的物品作为当前这一步放置的物品。记录一个当前时间 $t$ ，若当前队列为空，就将当前时间跳转到下一个物品的开始时间，否则将当前时间 $+ 1$ 。

时间复杂度 $O (n l o g n)$

#include <bits/stdc++.h>

using i64 = long long;

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int N;
	std::cin >> N;

	std::vector<std::pair<i64, i64>> info(N);
	for (int i = 0; i < N; i++) {
		i64 t, d;
		std::cin >> t >> d;

		info[i] = {t, t + d};
	}

	std::sort(info.begin(), info.end());

	int ans = 0;
	int i = 0;
	i64 now = 0;

	std::priority_queue<i64, std::vector<i64>, std::greater<>> h;
	while (true) {
		if (h.empty()) {
			if (i == N) {
				std::cout << ans << "\n";
				break;
			}
			now = info[i].first;
		}

		while (i < N && info[i].first == now) {
			h.push(info[i].second);
			i++;
		}

		while (!h.empty() && h.top() < now) {
			h.pop();
		}

		if (!h.empty()) {
			ans += 1;
			h.pop();
		}

		now += 1;
	}

	return 0;
}

E - Our clients, please wait a moment

题目是说边权会在某一个点处开始发生变化，所以其实只需要枚举这个发生变化的点就好了。

当然，如果在枚举这个点的过程中每次都从这个点向终点跑一次最短路一定是会超时的，所以我们应该预处理一下，从终点倒着跑一遍最短路，这样其实就能得到每个点到终点的最短路了。

时间复杂度 $n^{2}log(n)$

#include <bits/stdc++.h>

using i64 = long long;

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int N, A, B, C;
	std::cin >> N >> A >> B >> C;

	std::vector D(N, std::vector<int>(N));

	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N; j++) {
			std::cin >> D[i][j];
		}
	}

	std::priority_queue<std::pair<i64, int>, std::vector<std::pair<i64, int>>, std::greater<>> h;
	h.push({0, 0});
	std::vector<i64> dis1(N, 1E18);
	dis1[0] = 0;
	std::vector<bool> vis1(N);
	while (!h.empty()) {
		auto [d, x] = h.top();
		h.pop();	

		if (vis1[x]) {
			continue;
		}
		vis1[x] = true;
		for (int i = 0; i < N; i++) {
			if (!vis1[i] && dis1[i] > 1LL * A * D[x][i] + d) {
				dis1[i] = d + 1LL * A * D[x][i];
				h.push({d + 1LL * A * D[x][i], i});
			}
		}
	}

	std::priority_queue<std::pair<i64, int>, std::vector<std::pair<i64, int>>, std::greater<>> q;
	q.push({0, N - 1});
	std::vector<i64> dis2(N, 1E18);
	dis2[N - 1] = 0;
	std::vector<bool> vis2(N);
	while (!q.empty()) {
		auto [d, x] = q.top();
		q.pop();	

		if (vis2[x]) {
			continue;
		}
		vis2[x] = true;
		for (int i = 0; i < N; i++) {
			if (!vis2[i] && dis2[i] > d + 1LL * B * D[x][i] + C) {
				dis2[i] = d + 1LL * B * D[x][i] + C;
				q.push({d + 1LL * B * D[x][i] + C, i});
			}
		}
	}	

	i64 ans = 1E18;
	for (int i = 0; i < N; i++) {
		ans = std::min(ans, dis1[i] + dis2[i]);
		// std::cerr << "i: " << dis1[i] << " " << dis2[i] << "\n";
	}

	std::cout << ans << "\n";
	return 0;	
}

F - Sensor Optimization Dilemma

这种非此即彼的题一般都比较套路，在一个道具限定数量的条件下去枚举这一道具的数量， $d p$ 数组的属性就设计为另一种道具的数量。

记 $d p (i, j)$ 为前 $i$ 个物品使用 $j$ 个第一道具时所需第二道具的数量。

状态转移：dp[i][k] = std::min(dp[i][k], dp[i][j - 1] + (std::max(0, D[i] - (k - j) * L1) - 1 + L2) / L2)

#include <bits/stdc++.h>

using i64 = long long;

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	int N;
	std::cin >> N;

	std::vector<int> D(N + 1);
	for (int i = 1; i <= N; i++) {
		std::cin >> D[i];
	}

	int L1, C1, K1;
	std::cin >> L1 >> C1 >> K1;
	int L2, C2, K2;
	std::cin >> L2 >> C2 >> K2;

	std::vector dp(N + 1, std::vector<int>(K1 + 1, K2 + 1));
	for (int i = 0; i <= K1; i++) {
		dp[0][i] = 0;
	}
	for (int i = 1; i <= N; i++) {
		for (int j = 0; j <= K1; j++) {
			for (int k = j; k <= K1; k++) {
				int now = k - j;
				int surplus = std::max(0, D[i] - now * L1);
				dp[i][k] = std::min(dp[i][k], dp[i - 1][j] + (surplus + L2 - 1) / L2);
			}
		}
	}

	i64 ans = -1;
	for (int i = 0; i <= K1; i++) {
		if (dp[N][i] > K2) {
			continue;
		}
		if (ans == -1 || 1LL * C1 * i + 1LL * C2 * dp[N][i] < ans) {
			ans = 1LL * C1 * i + 1LL * C2 * dp[N][i];
		}
	}

	std::cout << ans << "\n";
	return 0;	
}

G - offence

题意和数据范围显然就是要区间DP，然后DP数组的属性定义为答案就好了。

由于可以多次删除of以及它后面的字符串，所以解决这道题的关键就是怎样将处理过的字符串再次处理。

我们考虑这样一件事情，如果字符o 和f并不相邻，那么这两个怎样才能再次删除呢？其实只要是这两个字符之间的DP答案为0就好了，那么状态转移就有了。

#include <bits/stdc++.h>

using i64 = long long;

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);

	std::string s;
	std::cin >> s;
	int t;
	std::cin >> t;

	const int n = s.size();
	std::vector dp(n + 1, std::vector<int>(n + 1));

	for (int len = 1; len <= n; len++) {
		for (int l = 0; l + len <= n; l++) {
			int r = l + len;
			dp[l][r] = dp[l + 1][r] + 1;
			
			if (s[l] == 'o') {
				for (int k = l + 1; k < r; k++) {
					if (s[k] == 'f' && dp[l + 1][k] == 0) {
						dp[l][r] = std::min(dp[l][r], std::max(0, dp[k + 1][r] - t));
					}
				}
			}
		}
	}

	std::cout << dp[0][n] << "\n";

	return 0;
}

Fr1nGeLove

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
AtCoder Beginner Contest 325题解（A~G） abc325

之间的格子里，然后每个格子只能放置一个物品，那么结束时间早的物品先放一定要优于结束晚的物品先放，但是如果说直接去枚举时间一定是会超时的，因此我们考虑从哪一方面进行优化。当然，如果在枚举这个点的过程中每次都从这个点向终点跑一次最短路一定是会超时的，所以我们应该预处理一下，从终点倒着跑一遍最短路，这样其实就能得到每个点到终点的最短路了。以开始时间为第一关键字、结束时间为第二关键字排序，用优先队列存储结束时间，每次弹出结束时间最早且大于等于当前时间的物品作为当前这一步放置的物品。个第一道具时所需第二道具的数量。
复制链接

扫一扫