2024年广州大学程序设计竞赛新生赛（同步赛）题解

比赛链接

A. 在ACM里打ACM

Solution

模拟题意即可，需要记录的信息是：总的罚时 $pen$，总共 $ac$ 的题目数量 $acc$，对 $13$ 个题都记录两个数，一个是 $fail$ 表示非 $ac$ 提交的额外罚时，一个是 $isAc$ 表示这题是否 $ac$，因为可能出现过了某个题还继续交的情况，这种情况应该忽略任何这道题的提交。

C++ Code

#include <bits/stdc++.h>

using i64 = int64_t;
using u64 = uint64_t;
using f64 = double_t;
using i128 = __int128_t;

struct Team {
   
    std::string s;
    int acc = 0;
    int pen = 0;
    std::array<int, 13> fail{
   };
    std::array<int, 13> isAc{
   };
};

int main() {
   
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    std::cout << std::fixed << std::setprecision(12);
    
    int n;
    std::cin >> n;

    std::vector<Team> team;
    std::map<std::string, int> mp;

    int m = 0;
    for (int i = 0; i < n; i++) {
   
        std::string s;
        char p;
        int ac;
        int t;
        std::cin >> s >> p >> ac >> t;
        if (!mp.contains(s)) {
   
            mp[s] = m++;
            team.push_back({
   s});
        }
        p -= 'A';
        int id = mp[s];
        if (ac == 0) {
   
            if (!team[id].isAc[p]) {
   
                team[id].fail[p] += 20;
            }
            continue;
        }
        if (!team[id].isAc[p]) {
   
            team[id].acc++;
            team[id].isAc[p] = 1;
            team[id].pen += t + team[id].fail[p];
        }
    }

    std::ranges::sort(team, [&](const auto &x, const auto &y) {
   
        if (x.acc != y.acc) {
   
            return x.acc > y.acc;
        }
        return x.pen < y.pen;
    });

    std::cout << team[0].s << " " << team[0].acc << " " << team[0].pen << "\n";
    
    return 0;
}

B. 逆=辶+屰

题目大意

给定一个数字 $n$ 和 $q$ 个询问，每个询问给出两个正整数 $k,r$，要求回答：

• 是否存在 $k$ 个 不同正整数 $c_1,c_2,\cdots ,c_k$满足 $n\equiv r(\mathrm{mod}{c}_i),i\in [1,k]$。

数据范围

• $1⩽n⩽10^6$；
• $1⩽q⩽10^4$;
• $1⩽k⩽10^6$；
• $0⩽r<n$；

Solution1

由同余的性质，得到 $(n-r)\equiv 0(\mathrm{mod}{c}_i),i\in [1,k]$，也就是说 $\forall c_i$ 都是 $n-r$ 的因数。

所以我们只要对 $n-r$ 进行质因数分解，然后计算所有 $>r$ 的因数有多少即可。

要保证 $>r$ 是因为，$r$ 是模 $c_i$ 后的结果，说明 $0⩽r<c_i$。

时间复杂度 $\mathcal{O}(q\sqrt{n-r})$

• 大约是 $10^4\times \sqrt{10^6}=10^7$，完全可以过。

C++ Code for Solution1

#include <bits/stdc++.h>

using i64 = long long;

int calc(int x, int r) {
   
    int ans = 0;
    for (int i = 1; i * i <= x; i++) {
   
        if (x % i == 0) {
   
            ans += i > r;
            if (i * i != x) {
   
                ans += x / i > r;
            }
        }
    }
    return ans;
}

int main() {
   
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, q;
    std::cin >> n >> q;

    while (q--) {
   
        int k, r;
        std::cin >> k >> r;

        int cnt = calc(n - r, r);
        if (cnt >= k) {
   
            std::cout << "YES\n";
        } else {
   
            std::cout << "NO\n";
        }
    }
    
    return 0;
}

Solution2

考虑到 $0⩽r<n$，所以 $n\equiv r(\mathrm{mod}{c}_i)$ 的 $c_i$ 一定不会超过 $n$，否则就有 $n\equiv n(\mathrm{mod}N)$，其中 $N>n$。

因此我们可以直接从 $1$ 到 $n$ 枚举可能的模数 $c_i$，用一个 $cnt$ 数组记录，例如 $cnt[i]$ 表示有多少 $c$ 满足 $n\equiv i(\mathrm{mod}c)$。

最后判断的时候只要看是否有 $cnt[r]⩾k$ 即可。

时间复杂度 $\mathcal{O}(n+q)$

C++ Code for Solution2

#include <bits/stdc++.h>

using i64 = long long;

int main() {
   
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int n, q;
    std::cin >> n >> q;

    std::vector<int> cnt(n);
    for (int i = 1; i <= n; i++) {
   
        cnt[n % i]++;
    }

    while (q--) {
   
        int k, r;
        std::cin >> k >> r;

        if (cnt[r] >= k) {
   
            std::cout << "YES\n";
        } else {
   
            std::cout << "NO\n";
        }
    }
    
    return 0;
}

C. 老树也有几颗新芽

题目大意

$Mortis$ 在穿过小巷时，遇到了一种奇特的硬币 $G$。一开始有 $n$ 枚 $G$，分别记为 $G_i,i\in [1,n]$，对应的本地计数器分别为 $cn{t}_i,i\in [1,n]$。一开始 $\forall cn{t}_i=0$。

现在你需要捡走地上所有的硬币。每一次操作你可以任选一枚硬币 $G_x$ 捡走，捡走后会按顺序发生以下事件：
① 随机选择一枚仍未被检走的 $G_y$，使被选择的 $G_y$ 的本地计数器 $cn{t}_y:=cn{t}_y+1$；
② 再在地上生成 $cn{t}_x$ 个新的硬币 $G$，均初始化 $cnt=0$ 。

已知 $Mortis$ 在每次操作时可以知道所有硬币的计数器 $cn{t}_i$，因此总会采取最优策略。

求在最坏情况下，至少需要多少次操作才能将所有的硬币捡走。

Solution

最坏原则：在最坏情况下，$cn{t}_i:=cn{t}_i+1$ 操作会尽可能落到 $cn{t}_i$ 较小的 $G_i$ 上，我们也应优先捡起 $cn{t}_i$ 较小的 $G_i$。因此对于 $n$ 枚 $\forall cn{t}_i=0$ 的硬币，若干次操作后总是会得到剩下一枚硬币 $G$ 的 $cnt=n-1$，然后捡起这枚硬币，将问题转化为捡起 $n-1$ 枚 $\forall cn{t}_i=0$ 的硬币。

我们用 $cdp[i]$ 表示将 $i$ 枚 $\forall cn{t}_j=0$ 的硬币全部捡起的最小操作次数，$cdp[0]=0$。

令 $dp[i]=cdp[i]-cdp[i-1]$，这样 $dp[i]$ 的定义就是从 $i$ 枚 $\forall cn{t}_j=0,j\in [1,i]$ 的硬币变为 $i-1$ 枚 $\forall cn{t}_j=0,j\in [1,i-1]$ 的硬币的最小操作次数。

下面求解 $dp[i]$。

我们可以根据最坏原则手玩一下前 $8$ 项 $dp$ 值，发现会得到 $1,2,3,5,6,10,11,16$。

例如 $dp[5]=6$ 的模拟如下（$[k]$ 表示计数器的值为 $k$）：

$$\begin{gathered} [0][0][0][0][0] \\ [0][0][0][1] \\ [0][1][1] \\ [1][2] \\ [0][3] \\ [4] \\ [0][0][0][0] \end{gathered}$$

再有 $dp[7]=11$ 的模拟如下：

$$\begin{gathered} [0][0][0][0][0][0][0] \\ [0][0][0][0][0][1] \\ [0][0][0][1][1] \\ [0][1][1][1] \\ [1][1][2] \\ [0][2][2] \\ [2][3] \\ [0][0][4] \\ [1][4] \\ [0][5] \\ [6] \\ [0][0][0][0][0][0] \end{gathered}$$

对于这个