SMU Summer 2024 Contest Round 3

SMU Summer 2024 Contest Round 3

寻找素数对

题意

给你一个偶数，找到两个最接近的素数，其和等于该偶数。

思路

处理出 1e5 以内的素数，然后遍历，更新最接近的答案。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

vector<int> euler_range(int n) {
    vector<int> phi(n + 1), prime;
    vector<bool> is_prime(n + 1, true);
    is_prime[1] = 0, phi[1] = 1;
    for (int i = 2; i <= n; i++) {
        if (is_prime[i]) prime.push_back(i), phi[i] = i - 1;
        for (int j = 0; j < (int)prime.size() && i * prime[j] <= n; j++) {
            is_prime[i * prime[j]] = 0;
            if (i % prime[j]) phi[i * prime[j]] = phi[i] * (prime[j] - 1);
            else {
                phi[i * prime[j]] = phi[i] * prime[j];
                break;
            }
        }
    }
    return prime;
}

const int N = 1e5;
auto pr = euler_range(N);

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

    int x;
    set<int> s(pr.begin(), pr.end());
    while (cin >> x) {
        int a = 0, b = 0;
        for (auto i : pr) {
            if (i > x) break;
            if (s.count(x - i)) {
                if (!a) a = i, b = x - i;
                else if (abs(x - i - i) < abs(a - b))
                    a = i, b = x - i;
            }
        }
        if (a > b) swap(a, b);
        cout << a << ' ' << b << '\n';
    }

    return 0;
}

抱歉

题意

平面上有 n 个点，每个点至少有 2 条曲线线段连接，所有曲线线段不相交，但是任意两点之间可以有多条曲线，问你 n 个点将平面分成了 m 份中存在的曲线线段数量。

思路

满足最小的条件，即每个点都能有两条曲线线段相连的图中最少有 n 条线段。

如图：

可以看出，最小符合条件的连线方式将平面分成了 2 份，又因为两点之间可以有多条曲线，所以每增加一个面只需要加一条曲线即可。

如图：

所以答案就是 \(n+m-2\)，记得开longlong。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

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

    i64 n,m;
    while(cin >> n >> m && n && m){
       	cout << n + m - 2 << '\n';
    }

    return 0;
}

搬寝室

题意

从 n 个物品中选出 2k 个物品，每两个物品产生的贡献是其重量差值的平方，求最小的贡献值。

思路

n 个选 2k 个，考虑dp。

因为要求差值的平方最小，所以我们将物品按重量按差值排序，排序后相邻的物品其重量差值相对最小。

然后处理出第 i 个物品与 i + 1 个物品间的差值平方。

设 \(dp_{i,j}\) 为前 i 个物品中搬运 j 次的最小贡献。

对于第 i 个物品，如果选择它，则答案是 i-1 物品与它的贡献加上 \(dp_{i-2,j-1}\) 时的贡献，如果不选，那答案就等于 \(dp_{i-1,j}\) 。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

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

    int n, k;
    while (cin >> n >> k) {
        vector<i64> w(n + 1);
        for (int i = 1; i <= n; i ++)
            cin >> w[i];

        sort(w.begin() + 1, w.end());

        vector<vector<i64>> dp(n + 1, vector<i64>(k + 1, LLONG_MAX / 2));

        vector<int> val(n + 1);
        for (int i = 1; i < n; i ++) {
            val[i] = pow(w[i + 1] - w[i], 2);
        }

        for (int i = 0; i <= n; i ++)
            dp[i][0] = 0;

        for (int i = 2; i <= n; i ++)
            for (int j = 1; j * 2 <= i && j <= k; j ++) {
                dp[i][j] = min(val[i - 1] + dp[i - 2][j - 1], dp[i - 1][j]);
            }

        cout << dp[n][k] << '\n';
    }

    return 0;
}

Nuts

题意

累加 n 个数大于 10 的部分。

思路

按题意模拟。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

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

    int n;
    cin >> n;

    int ans = 0;
    while (n --) {
        int x;

        cin >> x;
        ans += max(0, x - 10);
    }

    cout << ans << '\n';

    return 0;
}

Happy Birthday! 2

题意

给你一个含有 N 个正整数的序列 A，请你构造两个序列 B 和 C。

设这两个序列长度分别为 x 和 y，则应满足：

• \(1≤,≤\)
• \(1≤_,_≤\) 且两序列均严格递增
• \(B\) 与 \(C\) 互异
• \(∑_{=1}^_{_}≡∑_{=1}^_{C_i}( mod  200)\)

其中互异的定义：若 \(≠\) 或 \(=\) 但存在一个位置 使得 \(_≠_\)，则 \(B\) 与 \(C\) 互异。

思路

结论，在 201 个序列中一定存在两个在模 200 的情况余数相等的序列。

证明：若前面 200 个序列的余数两两不等，则第 201 个序列一定与前面某个序列的余数相等。

考虑到当 \(n=8\) 时，其子集序列达到了 256，所以我们可以直接枚举其所有子集，找到满足条件的序列，\(n < 8\) 时也是直接暴力枚举找到答案即可，\(n > 8\) 时必定有解，按照 \(n=8\) 的做法即可。

枚举时注意从 1 开始，因为最少要有一个被选。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

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

    int n;
    cin >> n;

    const int p = 200;

    vector<i64> w(n);
    for (auto &i : w)
        cin >> i;

    n = min(n, 8);

    map<int, vector<int>> mp;

    auto print = [](vector<int> num) {
        cout << num.size() << ' ';
        for (auto i : num)
            cout << i << " \n"[i == num.back()];
    };

    for (int i = 1; i < 1 << n; i ++) {
        i64 sum = 0;
        vector<int> tmp;

        for (int j = 0; j < n; j ++) {
            if ((i >> j) & 1) {
                sum = (sum + w[j]) % p;
                tmp.push_back(j + 1);
            }
        }

        if (mp.count(sum)) {
            cout << "Yes\n";
            print(mp[sum]);
            print(tmp);
            return 0;
        } else
            mp[sum] = tmp;
    }

    cout << "No\n";

    return 0;
}

Bowls and Dishes

题意

有 n 道菜和 m 个条件限制，每个条件要求第 \(A_i\) 道菜和第 \(B_i\) 道菜都有人投票才算满足，现有 k 个人，每个人可以在第 \(C_i\) 道菜和第 \(D_i\) 道菜中选择一个投票，现问你每个人投票后满足条件的菜的数量最多有多少。

思路

因为 k 最大只有 16 ，所以直接枚举即可。

0 表示第 i 个人投 \(C_i\) 道菜，1 表示其投 \(D_i\) 道菜。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

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

    int n, m;
    cin >> n >> m;

    vector<array<int, 2>> ab(m);
    for (auto &[a, b] : ab)
        cin >> a >> b;

    int k;
    cin >> k;
    vector<array<int, 2>> cd(k);
    for (auto &[c, d] : cd)
        cin >> c >> d;

    int ans = 0;
    for (int i = 0; i < 1 << k; i ++) {

        vector<int> dish(n + 1);
        for (int j = 0; j < k; j ++) {
            dish[cd[j][(i >> j) & 1]] ++;
        }

        int res = 0;
        for (auto [a, b] : ab)
            res += (dish[a] && dish[b]);
        ans = max(ans, res);
    }

    cout << ans << '\n';

    return 0;
}

Rush Hour 2

题意

给定一张 个点， 条边的无向图，每条边有两个属性 \(c_i,d_i\)。

你现在位于点 1，想要前往点 ，现在的时间是 0。当时间为 时经过第 条边所需的时间是 $c_i+\lfloor \frac{d_i}{t+1}\rfloor $ 。

你可以在城市中停留任意非负整数时间，请求出你到达点 n 所花费的最短时间，如果无法到达，输出 -1。

思路

假设当前时间为 t，经过第 i 座城市，则当前答案为 \(t + c_i+\lfloor \frac{d_i}{t+1}\rfloor\)，仔细观察 \(t + \frac{d}{t+1}\)，转化为 \(t+1+\frac{d}{t+1}-1\) ，其实就是中学时常说的对勾函数，当且仅当 \(t+1=\sqrt d\) 即 \(t=\sqrt d -1\) 时，取得最小值，所以当走到第 i 座城市的时候，判断一下该时的时间有没有到达 \(\sqrt d -1\)，没有就等到这个时候再走，大于这个时间直接走即可，其余就是普通的 \(dijkstra\) 。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

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

    int n, m;
    cin >> n >> m;

    vector g(n + 1, vector<array<int, 3>>());
    for (int i = 0; i < m; i ++) {
        int u, v, c, d;
        cin >> u >> v >> c >> d;
        g[u].push_back({v, c, d});
        g[v].push_back({u, c, d});
    }

    vector<i64> dis(n + 1, -1);
    using ar2 = array<i64, 2>;
    priority_queue<ar2, vector<ar2>, greater<>> Q;

    dis[1] = 0;
    Q.push({0, 1});

    while (Q.size()) {
        auto [time, u] = Q.top();
        Q.pop();

        if (dis[u] < time) continue;

        for (auto &[v, c, d] : g[u]) {
            i64 t = time, okt = round(sqrt(d)) - 1;
            if (t < okt) t = okt;

            if (dis[v] == -1 || dis[v] > t + c + d / (t + 1)) {
                dis[v] = t + c + d / (t + 1);
                Q.push({dis[v], v});
            }
        }
    }

    cout << dis[n] << '\n';

    return 0;
}

Count Descendants

题意

• 给出一个 \(n\) 个点的有根树，节点编号为 \(1, 2, \cdots n\)，树根为 \(1\)，第 \(i\)（\(2 \le i \le n\)）号节点的父亲是 \(p_i\)。

• 给出 \(q\) 个查询，第 \(i\) 个查询包含 \(a_i, b_i\)，计算满足以下条件的点 \(u\) 的个数：

  1、 \(a_i\) 位于 \(u\) 到 \(1\) 的最短路径上（端点也算）；

  2、\(u\) 到根上的路径恰好有 \(b_i\) 条边。

• \(n, q \le 2 \times 10^5, 0 \le b_i < n\)。

思路

前置知识：时间戳——树中的应用 - 岸南 - 博客园 (cnblogs.com)

由第一个条件可知满足条件的节点一定是 \(a_i\) 自己或是其子孙，判断其子孙可以采用时间戳，若一个点的 \([Tin_u,Tout_u]\) 被 \([Tin_{a_i},Tout_{a_i}]\) 包含。那么 u 就是 \(a_i\) 的子孙节点。

由第二个条件可得，从根节点到 u 的边就是指的 u 在树中的深度。

那么我们按照深度将节点的时间戳存进去，由于 dfs 是深度优先搜索，那么存进去的时间戳一定是升序排列，那么我们只要二分去找到该深度中被 \(a_i\) 的时间戳包含的个数就是我们要求的答案了。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

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

    int n;
    cin >> n;

    vector g(n + 1, vector<int>());
    for (int i = 2; i <= n; i ++) {
        int x;
        cin >> x;

        g[x].push_back(i);
    }

    int timer = 0;
    map<int, vector<int>> mp;
    vector<int> tin(n + 1), tout(n + 1);

    auto dfs = [&](auto && self, int u, int d)->void{
        tin[u] = timer ++;
        mp[d].push_back(tin[u]);
        for (auto v : g[u]) {
            self(self, v, d + 1);
        }
        tout[u] = timer ++;
    };

    dfs(dfs, 1, 0);

    int q;
    cin >> q;
    while (q--) {
        int u, d;
        cin >> u >> d;
        auto end = lower_bound(mp[d].begin(), mp[d].end(), tout[u]);
        auto start = lower_bound(mp[d].begin(), mp[d].end(), tin[u]);
        cout << end - start << '\n';
    }

    return 0;
}

To 3

题意

给你一个数，问你最少删除其中哪些位后使得该数能够被 3 整除。

思路

因为数最大只有 1e18，也就是最多只有 18 位，那么枚举一下删掉哪些位即可。

代码

#include<bits/stdc++.h>

using namespace std;

using i64 = long long;

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

    i64 n;
    cin >> n;

    i64 ans = -1;
    i64 len = 1, shi = 1, t = n / 10;
    while (t) {
        len ++, shi *= 10, t /= 10;
    }

    for (int i = 0; i < 1ll << len; i ++) {
        i64 res = 0, num = 0, t10 = shi;
        for (int j = 0; j < len; j ++) {
            if (!((i >> j) & 1)) res = res * 10 + (n / t10 % 10);
            else num ++;
            t10 /= 10;
        }

        if (res && res % 3 == 0) {
            if (ans == -1) ans = num;
            else ans = min(ans, num);
        }
    }

    cout << ans << '\n';

    return 0;
}