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

题解

知识点：贪心，枚举。

显然贪心取能取的最小字母作为密码环中上一个字母。

当自己已经有上一个字母时，可以直接取。

当自己还没有上一个字母时，考虑取的限制：

1. 自己不能取自己
2. 已经取过的字母不能再取，即这个字母已经有下一个字母，且不是自己
3. 把这个字母当作自己的上一个以后，会形成一个环且环的长度不是 \(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;
}