Codeforces Round #824 (Div. 2) A-E
A
题解
知识点：贪心，数学。
注意到三段工作时间一共 \(n-3\) 天，且天数实际上可以随意分配到任意一段，每段至少有一天，现在目的就是最大化段差最小值。
不妨设 \(l_1<l_2<l_3\) ，显然满足等式 \(l_2-l_1 = l_3-l_2 = k\) 时段差相等，即没有长度被浪费。
解得 \(2l_2-l_1 = l_3\) ，于是 \(3l_2 = n-3\) ，即 \(l_2 = \lfloor \frac{n-3}{3} \rfloor\) ，现在考虑余数部分分配。显然，多余的一天或者两天分配到 \(l_3\) 不会影响段差最小值，但分配到 \(l_1,l_2\) 只可能变小，所以 \(l_2\) 只能是 \(\lfloor \frac{n-3}{3} \rfloor\) ，余数全扔进 \(l_3\) 但对答案没影响，因此之后不考虑余数。
为使 \(k\) 最大，显然设 \(l_1 = 1,l_3 = 2l_2-1\) ，因此最终答案是 \(\lfloor \frac{n-3}{3} \rfloor - 1\)
时间复杂度 \(O(1)\)
空间复杂度 \(O(1)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
bool solve() {
int n;
cin >> n;
cout << (n - 3) / 3 - 1 << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
B
题解
知识点：贪心。
确定最小值 \(min\) ，把大于等于 \(2min\) 的数拆分了即可，且不会影响最小值。
一个数拆分的最小次数是 \(\lceil \frac{n}{2min-1} \rceil -1\) ，方法是每次把 \(2min-1\) 拆出来，能拆 \(\lceil \frac{n}{2min-1} \rceil -1\) 次，但最后一次拆会导致剩下的小于 \(min\) ，所以最后一次可以替换成对半拆，但不影响总次数。
时间复杂度 \(O(n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int a[107];
bool solve() {
int n;
cin >> n;
for (int i = 1;i <= n;i++) cin >> a[i];
int mi = *min_element(a + 1, a + 1 + n);
mi = mi * 2 - 1;
ll sum = 0;
for (int i = 1;i <= n;i++) {
if (a[i] > mi) sum += (a[i] + mi - 1) / mi - 1;
}
cout << sum << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
C
题解
知识点：贪心，枚举。
显然贪心取能取的最小字母作为密码环中上一个字母。
当自己已经有上一个字母时，可以直接取。
当自己还没有上一个字母时，考虑取的限制：
- 自己不能取自己
- 已经取过的字母不能再取，即这个字母已经有下一个字母，且不是自己
- 把这个字母当作自己的上一个以后，会形成一个环且环的长度不是 \(26\) 时，不能取。
满足上述限制的情况下取最小的字母即可。为了方便，可以只记录每个字母的上一个字母和有没有下一个字母，每个字母的下一个字母具体是什么其实不重要。
时间复杂度 \(O(n \cdot 26^2)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
bool vis[26];
int pst[26];
bool check(int a, int b) {
if (vis[b] || a == b) return false;
int k = b, cnt = 0;
while (~pst[k]) {
k = pst[k];
cnt++;
}
return k != a || cnt == 25;
}
bool solve() {
memset(vis, 0, sizeof(vis));
memset(pst, -1, sizeof(pst));
int n;
cin >> n;
string s;
cin >> s;
string ans;
for (int i = 0;i < s.size();i++) {
if (~pst[s[i] - 'a']) {
ans += pst[s[i] - 'a'] + 'a';
continue;
}
for (int j = 0;j < 26;j++) {
if (check(s[i] - 'a', j)) {
vis[j] = 1;
pst[s[i] - 'a'] = j;
ans += j + 'a';
break;
}
}
}
cout << ans << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
D
题解
知识点：枚举，数学，STL。
配成 set 的卡牌各个特征和都能被 \(3\) 整除，即 \(c[i][l] + c[j][l] + c[k][l] \equiv 0 \pmod 3\) ，表示能组成 set 的 \(i,j,k\) 三张牌的任意特征 \(l\) 的情况。
注意到卡牌两两不同，因此通过两张卡牌就能唯一确定另一张可以配对成 set 的卡牌的牌型，即 \(c[i][l] \equiv -c[j][l] - c[k][l] \pmod 3\) ，表示通过 \(j,k\) 两张牌能确定 \(i\) 的牌型，这也意味着不同的 set 至少有两张牌不同。
想要组成一个 meta-set ，需要五张牌组成至少两个 set ，但根据上面的结论，两个 set 至多有一个重复的牌，就已经有五张牌了。因此一个 meta-set 有五张牌，需要且只需要组成两个 set ，且其中一张牌会同时存在于两个 set 。
因此我们先遍历所有两张牌的组合（称为一对牌），得到能够和这一对牌组成 set 的牌型，并在这种牌型下计数，表示这种牌型可以和几对牌组成 set 。假如某种牌型下存在 \(cnt\) 对牌，则可以从中选 \(2\) 对组成 meta-set ，总计有 \(C_{cnt}^2\) 种方案。
最后遍历一遍牌，并通过之前记录的牌型与对数，计算方案总数，根据上面结论，这些方案不可能交叉。
时间复杂度 \(O(n^2k\log n)\)
空间复杂度 \(O(nk)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
bool solve() {
int n, k;
cin >> n >> k;
vector<vector<int>> c(n + 1, vector<int>(k));
for (int i = 1;i <= n;i++)
for (int j = 0;j < k;j++)
cin >> c[i][j];
map<vector<int>, int> mp;
for (int i = 1;i <= n;i++) {
for (int j = i + 1;j <= n;j++) {
vector<int> v(k);
for (int l = 0;l < k;l++)
v[l] = (6 - c[i][l] - c[j][l]) % 3;//找到与两张卡牌配对的第三张卡牌
mp[v]++;
}
}
int ans = 0;
for (int i = 1;i <= n;i++) {
int tmp = mp[c[i]];
ans += (tmp - 1) * tmp / 2;
}
cout << ans << '\n';
return true;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
//cin >> t;
while (t--) {
if (!solve()) cout << -1 << '\n';
}
return 0;
}
E
题解
知识点：枚举，STL。
因为 \(h_i\) 到 \(p_1,p_2\) 的距离是打乱的，可以通过枚举 \(p_1,p_2\) 之间的可能的间距，检查这个距离 \(dis\) 是否合法，从而推断出可能序列。
先固定一个端点的距离 \(d_1[0]\) ，匹配另一个端点距离 \(d_2[i]\) ，这样就能枚举到所有情况。此时有两种情况，第一种是点在 \(p_1,p_2\) 之间，即 \(dis = d_1[0] + d_2[i]\) ，第二种是点在 \(p_1,p_2\) 之外，即 \(dis = |d_1[0]-d_2[i]|\) ，两种都枚举一下即可。
先假设 \(p_1 = 0,p_2 = dis\) 。
在判断一个 \(dis\) 是否合法时，先把距离 \(x\) 大于 \(dis\) 的处理掉，即找到当前 \(d_1,d_2\) 中最大的且大于 \(dis\) 的，这种情况的点只可能在 \(p_1,p_2\) 之外。假设 \(x\) 在 \(d_1\) 中， \(diff = x-dis\) 一定存在于 \(d_2\) 中，否则就是 \(dis\) 不合法。存在的话就把 \(x,diff\) 从 \(d_1,d_2\)删掉， \(p_1+x\) 就是 \(h_i\) 之一。
之后没有在 \(p_1,p_2\) 之外的点时，剩下的点都在内部，则把当前 \(d_1\) 从小到大排序，\(d_2\) 从大到小排序，其对应位置之和都应该等于 \(dis\) ，否则就不合法。
最后要求输出非负数，所以把整个序列偏移一下即可。
时间复杂度 \(O(n^2\log n)\)
空间复杂度 \(O(n)\)
代码
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int n;
int d1[1007], d2[1007];
struct node {
multiset<int> ms;
void insert(int x) { ms.insert(x); }
int max() { return *prev(ms.end()); }
int size() { return ms.size(); }
void erase(int x) { ms.erase(ms.find(x)); }
bool exist(int x) { return ms.find(x) != ms.end(); }
};
bool check(int dis) {
node ms1, ms2;
for (int i = 1;i <= n;i++) ms1.insert(d1[i]), ms2.insert(d2[i]);
int p1 = 0, p2 = dis;
vector<int> ans;
while (ms1.size() && ms2.size() && max(ms1.max(), ms2.max()) >= dis) {//先清理在假定的p1,p2外的点
if (ms1.max() > ms2.max()) {//|p1-h|最长
int x = ms1.max();
int diff = x - dis;
if (!ms2.exist(diff)) return false;
ms1.erase(ms1.max());
ms2.erase(diff);
ans.push_back(p1 + x);
}
else {//|p2-h|最长
int x = ms2.max();
int diff = x - dis;
if (!ms1.exist(diff)) return false;
ms1.erase(diff);
ms2.erase(ms2.max());
ans.push_back(p2 - x);
}
}
vector<int> v1, v2;
for (auto i : ms1.ms) v1.push_back(i);
for (auto i : ms2.ms) v2.push_back(i);
reverse(v2.begin(), v2.end());
for (int i = 0;i < v1.size();i++) {//其他点都在内部
if (v1[i] + v2[i] != dis) return false;
}
for (auto i : v1) ans.push_back(i);
int diff = max(-*min_element(ans.begin(), ans.end()), 0);//保证最小坐标是非负的
cout << "YES" << '\n';
for (auto i : ans) cout << i + diff << ' ';
cout << '\n';
cout << diff << ' ' << dis + diff << '\n';
return true;
}
bool solve() {
cin >> n;
for (int i = 1;i <= n;i++) cin >> d1[i];
for (int i = 1;i <= n;i++) cin >> d2[i];
for (int i = 1;i <= n;i++) {
if (check(abs(d1[1] - d2[i]))) return true;
if (check(d1[1] + d2[i])) return true;
}
return false;
}
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
if (!solve()) cout << "NO" << '\n';
}
return 0;
}
本文来自博客园，作者：空白菌，转载请注明原文链接：https://www.cnblogs.com/BlankYang/p/16767592.html
