LGR-204-Div.2
质量不错的比赛。
A
比较明显的题，贪心往下做就可以。
#include <bits/stdc++.h>
using i64 = long long;
constexpr int N = 1e5 + 7;
int k;
int a[N];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> k;
for (int i = 1; i <= k; i++) {
std::cin >> a[i];
}
if (k == 1 && a[1] == 1) { std::cout << "1\n"; exit(0); }
std::sort(a + 1, a + k + 1);
int dep = 1, ans = 1;
for (int i = 1; i <= k; i++) {
ans += (a[i] - dep);
dep = a[i] - 1;
}
std::cout << ans << "\n";
return 0;
}
B
比较明显的题，模拟一下往下做就可以。
#include <bits/stdc++.h>
using i64 = long long;
void solve() {
int n;
std::string s;
std::cin >> n >> s;
int cnt = 1;
std::vector<int> a(n + 1);
if (s[0] == '=')
cnt = 2;
else
a[1] = 1;
char lst = s[0];
for (int i = 1; i < n - 1; i++) {
if (s[i] == '=') {
a[i + 1] = a[i];
cnt++;
}
else if (s[i] == s[i - 1]) {
a[i + 1] = a[i] + 1;
cnt = 1;
}
else if (s[i] != lst) {
a[i + 1] = cnt;
cnt = 1;
lst = s[i];
}
else if (s[i] == lst) {
a[i + 1] = a[i] + cnt;
cnt = 1;
}
}
i64 ans = 0;
for (int i = 0; i <= n; i++)
ans += a[i];
std::cout << ans << "\n";
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int t;
std::cin >> t;
while (t--) {
solve();
}
return 0;
}
C
观察到 \(m \leq 20\) 肯定不对劲，并且好像没有什么现成的方便的 DS 可以快速维护两序列区间排序并，注意到是一个诈骗题，直觉能够感受到在在不多次操作之后整个序列会趋向有序，这时可以直接考虑 swap() 掉，否则就暴力修改插入，然后发现这样是对的，可以证明最多只需要 \(O(m^2)\) 次操作，似乎是 \(\frac{m(m - 1)}{2}\)？
注意到它卡输入。
以后非必要没弄懂就不要乱解地址，你搞不明白，而且你 CSP 2024 已经炸了一次 set*。
#include <bits/stdc++.h>
using i64 = long long;
template <typename T> T read() {
T sum = 0, fl = 1;
int ch = getchar_unlocked();
for (; !isdigit(ch); ch = getchar_unlocked()) { if (ch == '-') fl = -1; }
for (; isdigit(ch); ch = getchar_unlocked()) sum = sum * 10 + ch - '0';
return sum * fl;
}
template <typename T> void write(T x) {
if (x < 0) { x = -x; putchar_unlocked('-'); }
if (x > 9) write(x / 10);
putchar_unlocked(x % 10 + '0');
}
void solve() {
int n = read<int>(), m = read<int>(), q = read<int>();
std::vector<int> G[m + 1];
std::vector<bool> vis(m + 1);
for (int x = 1; x <= m; x++) {
for (int i = 1, p; i <= n; i++) {
p = read<int>();
G[x].push_back(p);
}
}
while (q--) {
int opt = read<int>(), x = read<int>(), y = read<int>();
if (opt == 2) {
write<int>(G[x][y - 1]);
puts("");
} else {
if (vis[x] && vis[y]) {
/*if (*G[x].end() <= *G[y].begin())
continue;
if (*G[y].end() <= *G[x].begin()) {
std::swap(G[x], G[y]);
continue;
}*/
if (G[x][G[x].size() - 1] <= G[y][0])
continue;
if (G[y][G[y].size() - 1] <= G[x][0]) {
std::swap(G[x], G[y]);
continue;
}
}
std::vector<int> v;
v.insert(v.end(), G[x].begin(), G[x].end());
v.insert(v.end(), G[y].begin(), G[y].end());
std::sort(v.begin(), v.end());
for (int i = 0; i < n; i++)
G[x][i] = v[i];
for (int i = n; i < v.size(); i++)
G[y][i - n] = v[i];
vis[x] = vis[y] = 1;
}
}
}
int main() {
// std::ios::sync_with_stdio(false);
// std::cin.tie(nullptr);
solve();
return 0;
}
D
试判断是否存在一个 \(n\) 个 \(0\) 和 \(m\) 个 \(1\) 的 \(01\) 串满足对于任意一个长度 \([2L, 2R]\) 的子串，其 \(n\) 和 \(m\) 的数量不相等
学习了一个新的 trick。
对于 \(01\) 串个数相等的问题，可以考虑将其转到二维平面上走网格，选择一个 \(1\) 表示向下走一格，选择一个 \(0\) 表示向下走一格。
这样子做的话我们就成功转化了题面：从 \((m, n)\) 往 \((0, 0)\) 走，走到 \((0, 0)\)，每一次移动都会新产生几个障碍，求是否存在一条路径使其不经过障碍。
这样子看起来就可做了很多。
发现障碍的位置是随着移动的位置而平移的，贪心地贴着障碍边界往下走，如果最后障碍的边界与 \(x\) 轴的交点 \(\gt 0\) 就可行。
通过打表找一下周期，特殊处理 \(x\) 轴附近的点就解决问题了。
corner case 好像小多。
周期的探讨还是看 原的 Solution 比较好，照搬过来没什么意思。
好题。
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
void solve() {
u64 l, r, m, n;
std::cin >> l >> r >> m >> n;
if (!n || !m) {
std::cout << "Yes\n";
return;
}
if (l == 1) {
std::cout << "No\n";
return;
}
if (n > m) {
std::swap(n, m);
}
u64 a = (n - 1) / (l - 1);
u64 b = n - a * (l - 1);
u64 c = a * (l + 1) + std::min(b - 1, a * (r - l));
if (c <= m)
std::cout << "Yes\n";
else
std::cout << "No\n";
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int t;
std::cin >> t;
while (t--) {
solve();
}
return 0;
}
