2023牛客寒假算法基础集训营5 A-L
A
题解
知识点：前缀和，二分。
找到小于等于 \(x\) 的最后一个物品，往前取 \(k\) 个即可，用前缀和查询。
时间复杂度 \(O(n + q\log n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int a[100007];
ll sum[100007];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, q;
cin >> n >> q;
for (int i = 1;i <= n;i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1;i <= n;i++) sum[i] = sum[i - 1] + a[i];
while (q--) {
int k, x;
cin >> k >> x;
int pos = upper_bound(a + 1, a + n + 1, x) - a - 1;
cout << sum[pos] - sum[max(0, pos - k)] << '\n';
}
return 0;
}
B
题解
知识点：博弈论。
显然，每次取 \(1\) 是最优策略，但先拿的人串长肯定大于等于后拿的人，因此偶数平局，奇数后手胜。
时间复杂度 \(O(1)\)
空间复杂度 \(O(1)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
if (n & 1) cout << "Yaya-win!" << '\n';
else cout << "win-win!" << '\n';
return 0;
}
C
题解
知识点：数学。
分类讨论：
-
\(a,b\) 串长相等时，只有 \(a = b\) 时结果是
=，否则找到第一个不同的位置可以任意修改大小关系，结果是!。 -
\(a,b\) 串长不同时，不妨假设 \(a\) 比 \(b\) 长，那么首先就一定有 \(a>b\) 的情况，考虑 \(a\) 最小的情况会不会造成 \(a\leq b\) 。
若 \(a\) 超出 \(b\) 的部分不是相同的数，则一定不能全变成前导 \(0\) 此时无论如何一定有 \(a>b\) ，结果为
>；否则，先 \(a\) 超出部分全部变成前导 \(0\) ，此时 \(a,b\) 长度相同。之后，若 \(a = b\) 则结果为
!。否则，找到第一对不同的数，如果 \(b\) 的数是 \(a\) 前导数，则 \(a\) 无论如何都有 \(a>b\) ，结果为>，否则结果为!。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string a, b;
cin >> a >> b;
if (a.size() == b.size()) {
if (a == b) cout << "=" << '\n';
else cout << "!" << '\n';
return 0;
}
char ans = '>';
if (a.size() < b.size()) {
swap(a, b);
ans = '<';
}
char zero = a[0];
for (int i = 0;i < a.size() - b.size();i++) {
if (a[i] != zero) {
cout << ans << '\n';
return 0;
}
}
a.erase(a.begin(), a.begin() + a.size() - b.size());
if (a == b) {
cout << "!" << '\n';
return 0;
}
for (int i = 0;i < a.size();i++) {
if (a[i] != b[i]) {
if (b[i] == zero) cout << ans << '\n';
else cout << "!" << '\n';
return 0;
}
}
return 0;
}
D
题解
知识点：优先队列，枚举。
维护一个过关顺序，按照区间左端点从小到大排序即可，每次看看左端点最小的是不是小于等于自己在位置加 \(1\) ，然后更新右端点。
时间复杂度 \(O(n \log n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
pair<int, int> a[100007], b[100007];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1;i <= n;i++) cin >> a[i].first >> a[i].second;
for (int i = 1;i <= n;i++) cin >> b[i].first >> b[i].second;
priority_queue <pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq1, pq2;
int pos1 = 0, pos2 = 0;
for (int i = 1;i <= n;i++) {
pq1.push(a[i]);
pq2.push(b[i]);
while (pq1.size() && pq1.top().first <= pos1 + 1) {
pos1 = max(pos1, pq1.top().second);
pq1.pop();
}
while (pq2.size() && pq2.top().first <= pos2 + 1) {
pos2 = max(pos2, pq2.top().second);
pq2.pop();
}
if (pos1 > pos2) {
cout << "sa_win!" << '\n';
cout << pos1 - pos2 << '\n';
}
else if (pos1 < pos2) {
cout << "ya_win!" << '\n';
cout << pos2 - pos1 << '\n';
}
else {
cout << "win_win!" << '\n';
cout << 0 << '\n';
}
}
return 0;
}
E
题解
知识点：构造。
考虑将排列 \([1,2,\cdots,n] \to [n,n-1,\cdots ,1]\) ，这样每个数必然和其他数相遇一次。
每次交换全部顺序对，一定保证在 \(n\) 轮内完成交换。
时间复杂度 \(O(n^2)\)
空间复杂度 \(O(n^2)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> v(n + 1);
iota(v.begin(), v.end(), 0);
vector<vector<pair<int, int>>> ans;
while (!is_sorted(v.begin() + 1, v.end(), greater<int>())) {
vector<pair<int, int>> t;
for (int i = 1;i < n;i++) {
if (v[i] < v[i + 1]) {
swap(v[i], v[i + 1]);
t.push_back({ v[i],v[i + 1] });
i++;
}
}
ans.push_back(t);
}
cout << ans.size() << '\n';
for (auto i : ans) {
cout << i.size() << '\n';
for (auto [x, y] : i) cout << x << ' ' << y << '\n';
}
return 0;
}
F
题解
方法一
知识点：单调栈，贪心。
因为根据字典序，所以我们要尽可能使前面的字母更大。
考虑用单调栈维护前缀字典序最大的子序列，同时需要维护 \(k\) ，若 \(k = 0\) 则不能再弹出元素。若到最后 \(k>0\) ，则还可以对得到的子序列从后往前弹出，可能使字典序更大。将弹出的元素计数，最后从大到小一并加到子序列后面。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
方法二
知识点：枚举，贪心。
预处理 \(nxt_{i,j}\) 表示字符串 \([i,n]\) 的位置中字母 \(j\) 第一个出现的位置。随后只需要从大到小枚举 \(j\) ，找到最大的且能操作到的字母 \(j\) ，将 \(s_i\) 到 \(j\) 的所有元素全部操作一遍，并计数。
处理出来的是字典序最大的子序列，此时若 \(k\) 还有剩下的，那就从后往前依次弹出子序列元素，同样计数。
最后将跳过的或弹出的元素从大到小安排到子序列后面即可。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
方法一
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
array<int, 26> cnt{};
string ans;
for (auto ch : s) {
while (k && ans.size() && ans.back() < ch) {
cnt[ans.back() - 'a']++;
ans.pop_back();
k--;
}
ans += ch;
}
while (k && ans.size()) {
cnt[ans.back() - 'a']++;
ans.pop_back();
k--;
}
for (int i = 25;i >= 0;i--) ans += string(cnt[i], i + 'a');
cout << ans << '\n';
return 0;
}
方法二
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int nxt[100007][26];
int cnt[26];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int i = 0;i < 26;i++) nxt[n][i] = -1;
for (int i = n - 1;i >= 0;i--) {
for (int j = 0;j <= 25;j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i;
}
string ans;
for (int i = 0, nnxt;i < s.size(); i = nnxt + 1) {
for (int j = 25;j >= 0;j--) {
if (~nxt[i][j] && nxt[i][j] - i <= k) {
nnxt = nxt[i][j];
break;
}
}
for (int j = i;j < nnxt;j++) cnt[s[j] - 'a']++;
ans += s[nnxt];
k -= nnxt - i;
}
while (k && ans.size()) {
cnt[ans.back() - 'a']++;
ans.pop_back();
k--;
}
for (int i = 25;i >= 0;i--) if (cnt[i]) ans += string(cnt[i], i + 'a');
cout << ans << '\n';
return 0;
}
G
题解
知识点：二分图，图匹配。
对于每个需要填的位置，由两侧已知的数字可以得到两个待选的数字，如 \(0,x,5 \to x = 1,4\) ，除了最后一个空位因为只需要和第 \(n-1\) 个数字有一位不同，所以有更多可能。
注意到每个数字只能选一次，换句话说，空位和数字是一一配对关系。考虑画成二分图，题目保证一定有解，所以只要匹配一次即可。可以使用匈牙利算法或者网络流求解二分图匹配，这里采用匈牙利算法。
直接使用复杂度是跑满 \(O(n^2)\) 的（但是交了也能过？），根本原因是每次跑完一个点的增广路，需要把访问标记全清空，复杂度是 \(O(n)\) 的。但实际上没有必要，考虑对于某次增广失败的所有右部点，他们的左部配对没有任何变化，无论你用哪个其他的左部点去配对这些增广失败的右部点，这些右部点都会走原来的路径，而原来的路径依旧是失败的，根本没必要再走一次。因此，我们每次配对的时候，如果某个右部点增广失败了，就保留访问标记，不需要清空，而只清空成功的增广路上的所有访问标记，这个只需要在dfs最后加上清空即可，能让算法跑的巨快。
特别地在这道题，每个点最多被访问四次就会被永久标记，复杂度变成线性。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Graph {
struct edge {
int v, nxt;
};
int idx;
vector<int> h;
vector<edge> e;
Graph(int n = 0, int m = 0) { init(n, m); }
void init(int n, int m) {
idx = 0;
h.assign(n + 1, 0);
e.assign(m + 1, {});
}
void add(int u, int v) {
e[++idx] = { v,h[u] };
h[u] = idx;
}
};
const int N = (1 << 16) + 7, M = N;
Graph g;
int n;
int a[N];
int p[M], vis[M];
bool dfs(int u) {
for (int i = g.h[u];i;i = g.e[i].nxt) {
int v = g.e[i].v - n - 1;
if (vis[v]) continue;
vis[v] = 1;
if (p[v] && !dfs(p[v])) continue;
p[v] = u;
vis[v] = 0;
return true;
}
return false;
}
int Hungary() {
int cnt = 0;
for (int i = 2;i <= n;i += 2) cnt += dfs(i);
return cnt;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
g.init(2 * n, 2 * n + n);
for (int i = 1;i <= n;i += 2) cin >> a[i], vis[a[i]] = 1;
for (int i = 2;i < n;i += 2) {
int t = a[i - 1] ^ a[i + 1];
int x1 = a[i - 1] ^ (t & -t);
t -= t & -t;
int x2 = a[i - 1] ^ (t & -t);
if (!vis[x1]) g.add(i, x1 + n + 1);
if (!vis[x2]) g.add(i, x2 + n + 1);
}
for (int i = 0;i < 16 && (1 << i) <= a[n - 1];i++) {
int x = a[n - 1] ^ (1 << i);
if (!vis[x]) g.add(n, x + n + 1);
}
Hungary();
for (int i = 0;i < n;i++) if (p[i]) a[p[i]] = i;
for (int i = 1;i <= n;i++) cout << a[i] << ' ';
cout << '\n';
return 0;
}
H
题解
知识点：模拟。
直接按照要求模拟即可。
时间复杂度 \(O(n)\)
空间复杂度 \(O(1)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int x, y, k, n;
ll t;
cin >> x >> y >> k >> n >> t;
ll sum = 0, cnt = 0, nowc = x;
for (int i = 1;i <= n;i++) {
sum += nowc * (n - i + 1);
cnt += n - i + 1;
nowc = x + cnt / k * y;
if (sum >= t) {
cout << i << '\n';
return 0;
}
}
cout << -1 << '\n';
return 0;
}
I
题解
知识点：贪心。
为了保证一定不会输，我们从后往前考虑。
若最后一局才一赢，但赢回本至少需要留 \(\left\lceil \dfrac{m}{2} \right\rceil\) ，但我们希望在前面赢的多，因此我们留最少的 \(\left\lceil \dfrac{m}{2} \right\rceil\) ，则剩下 \(\left\lfloor \dfrac{m}{2} \right\rfloor\) ；若在 \(n-1\) 局才赢，那么至少需要留除去第 \(n\) 局剩下部分的一半取上整，同样的我们留最少的就行，以此类推，最后剩下的所有给第一局，若中途不够分，则无解。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll a[100007];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
ll m;
cin >> n >> m;
for (int i = n;i >= 1;i--) {
if (!m) {
cout << -1 << '\n';
return 0;
}
if (i == 1) a[i] = m;
else {
a[i] = (m + 1) / 2;
m -= (m + 1) / 2;
}
}
for (int i = 1;i <= n;i++) cout << a[i] << " \n"[i == n];
return 0;
}
J
题解
知识点：构造
属于灵光一现题qwq。
我们需要尽可能构造一条单向通道，这样才能保证尽可能多的格子都会被踩到。
可以考虑螺旋形，先考虑偶数情况，例如 \(n=6\) 从 \((1,1)\) 出发向右：
注意到每次经过下划线处会加 \(1\) 。
奇数情况取偶数情况左下角矩形即可，出发点在 \((n,n)\) 。
具体实现可以看代码。
时间复杂度 \(O(n^2)\)
空间复杂度 \(O(n^2)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int a[1007][1007];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
bool odd = n & 1;
if (odd) cout << n << ' ' << n << '\n', n++;
else cout << 1 << ' ' << 1 << '\n';
int x = 1, y = 1, cur = 0;
for (int i = 1;i <= n / 2;i++) {
for (int j = 1;j <= n - 2 * (i - 1) - 1;j++) {
a[x][y] = cur;
if (y == n / 2) (cur += 1) %= 3;
y++;
}
for (int j = 1;j <= n - 2 * (i - 1) - 1;j++) {
a[x][y] = cur;
if (x == n / 2) (cur += 1) %= 3;
x++;
}
for (int j = 1;j <= n - 2 * (i - 1) - 1;j++) {
a[x][y] = cur;
y--;
}
for (int j = 1;j <= n - 2 * (i - 1) - 1;j++) {
a[x][y] = cur;
x--;
}
x++, y++;
}
if (odd) n--;
for (int i = 1 + odd;i <= n + odd;i++)
for (int j = 1;j <= n;j++)
cout << a[i][j] << " \n"[j == n];
cout << n * n - 1 << '\n';
return 0;
}
K
题解
知识点：贪心。
每次最多可以淘汰 \(\left\lfloor \dfrac{x}{2} \right\rfloor\) 个人，只要取 \(\left\lceil \dfrac{x}{2} \right\rceil\) 即可。
特别地，若 \(x = 1,2\) ，则一定无法继续淘汰人。
时间复杂度 \(O(\log x)\)
空间复杂度 \(O(1)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll x;
cin >> x;
int cnt = 0;
while (x > 2) {
x = x / 2 + 1;
cnt++;
}
cout << cnt << '\n';
return 0;
}
L
题解
知识点：线性dp。
设 \(f_i\) 为剩余 \(i\) 个人的最小花费。初始状态为 \(f_n = 0\) 其他无穷大，转移方程见代码。
最后从小到大遍历一次就能获得人数最小的最小花费。
时间复杂度 \(O(nm)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int b[507], x[507];
ll f[100007];
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1;i <= m;i++) cin >> b[i] >> x[i];
for (int i = 1;i <= n;i++) f[i] = 1e18;
f[n] = 0;
for (int i = n;i >= 3;i--) {
if (f[i] >= 1e18) continue;
for (int j = 1;j <= m;j++) {
if (i >= x[j]) f[i / x[j] * x[j]] = min(f[i / x[j] * x[j]], f[i] + b[j]);
}
}
for (int i = 1;i <= n;i++) {
if (f[i] < 1e18) {
cout << f[i] << '\n';
break;
}
}
return 0;
}
本文来自博客园，作者：空白菌，转载请注明原文链接：https://www.cnblogs.com/BlankYang/p/17099114.html
