【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（4）

转载于 2025-05-01 14:41:34 发布 · 21 阅读

合集 - 杭电2025春季营(8)

1.【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（1）03-08 2.【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（2）03-15 3.【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（3）03-22

4. 【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（ 4） 03-29

5.【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（5）04-05 6.【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（6）04-12 7.【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（7）04-20 8.【杭电多校比赛记录】2025“钉耙编程”中国大学生算法设计春季联赛（8）04-27

比赛链接
本文发布于博客园，会跟随补题进度实时更新，若您在其他平台阅读到此文，请前往博客园获取更好的阅读体验。
跳转链接：https://www.cnblogs.com/TianTianChaoFangDe/p/18799072

开题 + 补题情况

和前三场比起来前期的签到题发挥稳定了许多，没有被卡很久，不过 1001 还是因为自己读错题挂了三发，不太应该。
虽然 rank 比之前有提升了，但是还是没有开出除了签到题之外的题，开的题价值不大，自己能力的提升还任重道远啊。

1006 - 进步

第一题就开的这个题。
此题涉及到修改某一天的进步量，查询某个时间区间的进步量，所以是单点修改，区间查询，很容易想到使用树状数组来维护。

点击查看代码

#include <bits/stdc++.h>
#define inf32 1e9
#define inf64 2e18
#define ls o << 1
#define rs o << 1 | 1

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;

const int N = 2e5 + 9;

template<typename T>
struct BIT {
    std::vector<T> t;
    int n;

    BIT(int n) {
        this -> n = n;
        t = std::vector<T>(n + 1, T(0));
    }

    int lowbit(int x) {
        return x & -x;
    }

    void add(int ix, T v) {
        for(int i = ix;i <= n;i += lowbit(i)) {
            t[i] += v;
        }
    }

    T query(int ix) {
        T res = 0;
        for(int i = ix;i > 0;i -= lowbit(i)) {
            res += t[i];
        }
        return res;
    }
};

void solve()
{
    int n, q;std::cin >> n >> q;
    std::vector<i64> a(n + 1);

    for(int i = 1;i <= n;i ++) {
        std::cin >> a[i];
    }

    BIT<i64> t(n + 1);

    for(int i = 1;i <= n;i ++) {
        t.add(i, a[i]);
    }

    i64 ans = 0;
    int sum = 0;

    while(q --) {
        int op;std::cin >> op;
        if(op == 1) {
            int x, y;std::cin >> x >> y;
            t.add(x, y - a[x]);
            a[x] = y;
        } else {
            sum ++;
            int l, r;std::cin >> l >> r;
            i64 e = t.query(r);
            i64 s = t.query(l - 1);

            e = e / 100;
            s = s / 100;
            
            ans ^= ((e - s) * sum);
        }
    }

    std::cout << ans << '\n';
}

1008 - 制衡

一开始看到题目，以为是一个需要人类智慧的 DP 题，直到发现了这两个重要线索：

允许某些段留空。
\(j\) 的最大值刚好就是 \(k\)。

那么转化一下就可以发现，我们的选择，只会往下方及右下方转移。
那么 DP 转移方程就很明显了：\(dp_{i, j} = \max(dp_{i - 1, l}) + a_{i, j},l \in [1, j]\)。
因此，在处理完了每一行的 DP 值后，要转化为前缀最值，便于优化转移。
时间复杂度：\(O(nk)\)。

点击查看代码

#include <bits/stdc++.h>
#define inf32 1e9
#define inf64 2e18
#define ls o << 1
#define rs o << 1 | 1

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;

const int N = 2e5 + 9;

void solve()
{
    int n, k;
    std::cin >> n >> k;

    std::vector<std::vector<int>> a(n, std::vector<int>(k));
    auto dp = a;

    for(auto &i : a) {
        for(auto &j : i) {
            std::cin >> j;
        }
    }

    for(int j = 0;j < k;j ++) {
        dp[0][j] = a[0][j];
        if(j > 0)dp[0][j] = std::max(dp[0][j], dp[0][j - 1]);
    }

    for(int i = 1;i < n;i ++) {
        for(int j = 0;j < k;j ++) {
            dp[i][j] = dp[i - 1][j] + a[i][j];
        }

        for(int j = 1;j < k;j ++) {
            dp[i][j] = std::max(dp[i][j], dp[i][j - 1]);
        }
    }

    std::cout << dp[n - 1][k - 1] << '\n';
}

1005 - 持家

这个题和 CF2078D 有异曲同工之妙。
首先，根据小学数学知识可以知道，打 \(x\) 折的意思是当前价格乘 \(x / 10\)。
也就是说，打折是和当前价格相关的，而减价是和当前价格无关的，无论当前价格多少，减的是多少就是多少。
而根据乘法的知识我们又能知道，若当前的价格越高，优惠力度会越大，因此对于打折券，一定是价格越高的时候用越好。
那么，如果我们使用了降价券，就一定不会再次使用任何一张打折券，因为此时只需要交换打折券和降价券的使用顺序，先打折后降价，我们就能获得更大的优惠力度。
因此，此题的做法就很明显了，我们枚举打折券的使用数量，剩下的就是降价券的使用数量，对于打折券，越低的折扣越优先使用，对于降价券，越高的降价越优先使用，因此可以对两种券分别排序，然后记录一下前缀乘积和前缀和，然后枚举计算取最优解即可。
时间复杂度：\(O(n)\)。

点击查看代码

#include <bits/stdc++.h>
#define inf32 1e9
#define inf64 2e18
#define ls o << 1
#define rs o << 1 | 1

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;

const int N = 2e5 + 9;

void solve()
{
    double p;std::cin >> p;
    int n, k;std::cin >> n >> k;

    std::vector<double> dazhe;
    std::vector<i64> jian;
    for(int i = 1;i <= n;i ++) {
        int op;std::cin >> op;
        i64 v;std::cin >> v;

        if(op == 0) {
            dazhe.push_back(1.0 * v / 10);
        } else {
            jian.push_back(v);
        }
    }

    sort(dazhe.begin(), dazhe.end());
    sort(jian.begin(), jian.end(), std::greater());

    
    for(int i = 1;i < dazhe.size();i ++) {
        dazhe[i] *= dazhe[i - 1];
    }
    
    for(int i = 1;i < jian.size();i ++) {
        jian[i] += jian[i - 1];
    }

    double ans = p;
    for(int i = 0;i <= std::min(k, (int)dazhe.size());i ++) {
        int d = i;
        int j = k - d;

        
        if(d > dazhe.size() || j > jian.size())continue;
        double tmp = p;
        if(d <= 0) {
            tmp = tmp - jian[j - 1];
        } else if(j <= 0) {
            tmp = tmp * dazhe[d - 1];
        } else {
            tmp = tmp * dazhe[d - 1] - jian[j - 1];
        }
        
        ans = std::min(ans, tmp);
        ans = std::max(ans, 0.00);
    }

    std::cout << ans << '\n';
}

int main()
{
    std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);

    std::cout << std::fixed << std::setprecision(2);

    int t = 1;std::cin >> t;
    while(t --)solve();

    return 0;
}

1001 - 战斗爽

就是这个题，读假了，读成了怪物每多受一次攻击，下次受到的伤害就要继续减半。
这个题纯模拟题，按题意模拟即可。
我们开一个结构体，存储怪物的编号，血量，攻击力，被攻击次数的信息，并且按题意重载小于号运算符，存入一个优先队列 \(pq\)。
再开一个结构体，存储怪物的攻击力，编号信息，并且按攻击力从小到大重载小于运算符，存入一个优先队列 \(sha\)。
再开一个数组，存储怪物的血量。

然后就可以开始模拟了，只要我们还活着，并且怪物还有活着的，就从优先队列 \(pq\) 中取出堆顶的怪物，并对它进行攻击，更新怪物的血量和被攻击次数，如果他还有血量，并且被攻击次数不满 \(k\) 次，就放回优先队列 \(pq\) 中，若没有血量了，就添加到答案中，然后检查优先队列 \(sha\) 的堆顶怪物是否存活，若死亡，则弹出优先队列，直到堆顶怪物存活，并对我们进行攻击，按照此逻辑模拟至我们死掉或是怪物全死掉为止，输出答案。
时间复杂度：\(O(tn\log n)\)，非常的极限。

点击查看代码

#include <bits/stdc++.h>
#define inf32 1e9
#define inf64 2e18
#define ls o << 1
#define rs o << 1 | 1

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;

const int N = 2e5 + 9;

struct monster {
    int id, g, x, cnt;
    bool operator < (const monster &v) const {
        if(x != v.x)return x > v.x;
        else if(g != v.g)return g > v.g;
        else if(id != v.id)return id > v.id;
    }
};

struct guai {
    int id, g;
    bool operator < (const guai &v) const {
        return g < v.g;
    }
};

void solve()
{
    int n, u, k, h;std::cin >> n >> u >> k >> h;
    std::vector<int> a(n + 1);

    std::priority_queue<monster> pq;
    std::priority_queue<guai> sha;

    for(int i = 1;i <= n;i ++) {
        int g, x;std::cin >> g >> x;
        a[i] = x;

        pq.push({i, g, x, 0});
        sha.push({i, g});
    }

    int ans = 0;
    while(h && pq.size()) {
        monster now = pq.top();
        pq.pop();

        if(now.cnt)now.x -= u / 2;
        else now.x -= u;
        now.cnt ++;
        now.x = std::max(0, now.x);
        a[now.id] = now.x;
        if(now.x && now.cnt < k)pq.push(now);
        if(!now.x)ans ++;

        while(sha.size() && a[sha.top().id] == 0) {
            sha.pop();
        }

        
        if(sha.size()) {
            h -= sha.top().g;
            h = std::max(h, 0);
        }
    }

    std::cout << ans << '\n';
}

1004 - 充实（补题）

这个题从二进制的角度来看，其实就是每次将一个偶数距离右移一位，并在中间插入一个和起点以及终点间隔该偶数一半距离的数字，那么，如果要让这些数字连续，这个间距最后应该变成 \(1\)，也就是说要出现一次偶数间距为 \(2\) 的次幂。
根据题解所说，每次操作等价于让较大的数减去较小的数，也就是 \((a, b) \rightarrow (a - b, b)\)，因此可以想到 \(gcd\)，所以，对所有间距取一个 \(gcd\)，如果结果是 \(2\) 的次幂，就一定可以，否则不可以。
（但说实话题解讲的我还是没看懂，有大佬明白的跪求再指点一下 T_T）

点击查看代码

#include <bits/stdc++.h>
#define inf32 1e9
#define inf64 2e18
#define ls o << 1
#define rs o << 1 | 1

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;

const int N = 2e5 + 9;

void solve()
{
    int n;std::cin >> n;
    std::vector<std::vector<int>> g(n + 1);

    for(int i = 2;i <= n;i ++) {
        int x;std::cin >> x;
        g[x].push_back(i);
    }

    std::vector<i64> a(n + 1);
    for(int i = 1;i <= n;i ++) {
        std::cin >> a[i];
    }

    int ans = 0;

    auto dfs = [&](auto &&self, int st, int pre, int gcd) -> void {
        if(st != 1)gcd = std::gcd(gcd, abs(a[st] - a[pre]));

        if(g[st].size() == 0) {
            ans += ((gcd & (gcd - 1)) == 0);
            return;
        }

        for(auto &i : g[st]) {
            self(self, i, st, gcd);
        }
    };

    dfs(dfs, 1, 0, 0);

    std::cout << ans << '\n';
}

1003 - 洞察（补题）

二进制的题，一定要从二进制的角度来思考。
我们发现，对于一个区间的数，如果他们第 \(i\) 位以上的位都相同，那么对于这个区间的数的第 \(i\) 位，必然是前面一半 \(0\)，后面一半 \(1\)，其实也就是 01trie 树那样子，那么也就是说，\(0,1\) 的情况具有单调性，因此是可以二分的。
那么，我们就可以像 01trie 树的思路来做（并不是真的要建一棵 01trie 树）。
首先将目标区间设置为范围内的所有数，然后从高位到低位考虑：

如果 \(v\) 这一位为 \(1\)，继续考虑 \(c\) ：如果 \(c\) 这一位为 \(p\)，那么 \(kx + b\) 这一位为 \(p\) 的区间可以直接加进答案，\(kx + b\) 为 \(p \oplus 1\) 的区间需要继续往后面的位讨论。
如果 \(v\) 这一位尾 \(0\)，继续考虑 \(c\) ：如果 \(c\) 这一位为 \(p\)，那么当且仅当 \(kx + b\) 这一位为 \(p\) 的时候需要继续往后面的位讨论，\(kx + b\) 为 \(p \oplus 1\) 的区间一定大于 \(v\)。

按照上述逻辑从高位到低位逐步缩小区间并加上符合的答案即可，最后所有位贪心完了如果区间还有剩余也要记得加上来。

点击查看代码

#include <bits/stdc++.h>
#define inf32 1e9
#define inf64 2e18
#define ls o << 1
#define rs o << 1 | 1

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;

const int N = 2e5 + 9;

void solve()
{
    i64 k, b, c, v;std::cin >> k >> b >> c >> v;

    i64 l = 0, r = ((1ll << 62) - 1 - b) / k;

    auto bs = [&](i64 s, i64 e, int bit) -> i64 {
        while(s + 1 != e) {
            i64 mid = (s + e) >> 1;
            if((k * mid + b) >> bit & 1) e = mid;
            else s = mid;
        }
        return s;
    };

    i64 ans = 0;

    for(int i = 61;i >= 0;i --) {
        if(l > r)break;
        i64 m = bs(l - 1, r + 1, i);
        int nowc = (c >> i & 1);
        int nowv = (v >> i & 1);

        if(nowv == 1) {
            if(nowc == 1) {
                ans += r - m;
                r = m;
            } else {
                ans += m - l + 1;
                l = m + 1;
            }
        } else {
            if(nowc == 1) {
                l = m + 1;
            } else {
                r = m;
            }
        }
    }

    if(l <= r)ans += r - l + 1;

    std::cout << ans << '\n';
}

1010 - 图之图（补题）

首先根据题意这个图一定是一个有向无环图，因此可以考虑拓扑排序 DP。
但是，这个题的建图方式导致这个题建图的复杂度就会特别高，因此实际建一个图是不可行的。
那怎么办呢？
我们注意到，连边是颜色和颜色之间连边，而点和点之间连边是固定从小到大的，那么，我们可以直接从小到大枚举，并将答案的贡献加到颜色上，这样可以保证当前所有颜色的贡献来源于比自己小的点，汇总当前的答案也只需要汇总到颜色上，便于后面的传递。
但是颜色的数量级也是 \(10^5\) 的，如果暴力转移，显然是会 TLE 的。
这时可以考虑进行根号分治。
根号分治，首先我们要设置一个阈值 \(k\)：

对于度数 \(\leq k\) 的颜色，我们枚举它的出边，把所有出边的颜色的路径值加到当前颜色上即可，此操作的时间复杂度为 \(O(k)\)。
对于度数 \(> k\) 的颜色，我们不在找到它的时候来加路径值，因为它的出边过多，而是反过来，在每次计算出了一个颜色新增的路径数后，同时把新增的添加到这个颜色相邻的度数 \(> k\) 的颜色上，此操作的时间复杂度为 \(O(m / k)\)。

那么总的时间复杂度就是 \(O(k + m / k)\)，为了平衡两个操作的时间复杂度，根据基本不等式的知识可以知道 \(k + m / k \geq 2\sqrt{m}\)，当且仅当 \(k = \sqrt{m}\) 时取等号，因此总的时间复杂度为 \(O(n\sqrt{m})\)。

点击查看代码（省略了取模类）

void solve()
{
    int n, c;std::cin >> n >> c;
    std::vector<int> a(n + 1);

    for(int i = 1;i <= n;i ++) {
        std::cin >> a[i];
    }

    int m;std::cin >> m;

    std::vector<std::vector<int>> g(c + 1), h(c + 1);

    for(int i = 1;i <= m;i ++) {
        int u, v;std::cin >> u >> v;
        g[u].push_back(v);
        if(u != v)g[v].push_back(u);
    }

    int k = sqrtl(m);
    std::vector<bool> vis(c + 1);
    for(int i = 1;i <= c;i ++) {
        if(g[i].size() >= k) {
            vis[i] = true;
            for(auto &j : g[i]) {
                h[j].push_back(i);
            }
        }
    }

    std::vector<Z> dat(c + 1), sum(c + 1);

    for(int i = 1;i <= n;i ++) {
        int now = a[i];
        Z cur = (i == 1);

        if(vis[now]) {
            cur += dat[now];
        } else {
            for(auto &j : g[now]) {
                cur += sum[j];
            }
        }

        if(i == n) {
            std::cout << cur << '\n';
            break;
        }

        sum[now] += cur;
        for(auto &j : h[now]) {
            dat[j] += cur;
        }
    }
}

1007 - 童年（补题）

典型博弈模型。
博弈论，遇事不决，从后往前推，我们记 \(xa, xb\) 为先手的两个数字，\(ya, yb\) 为后手的两个数字，记 \(dp_{xa,xb,ya,yb}\) 为此时先手必胜还是必败还是平局。
博弈论，可以抽象为一个状态图，并有以下规则：

若一个状态连向的所有状态都是先手必胜态，则这个状态为先手必败态。
若一个状态有任何一个状态连向了先手必败态，则这个状态为先手必胜态。
剩余的情况，则为平局态，也就是说，平局态会相互连接并且成环。

那么，我们就可以使用这个规则，建一个反图，从游戏结束时的状态往回推进行 DP：

若一个状态是必胜态，则这个状态连向的所有状态计数 \(+1\)，当计数等于连向的这个状态的入度时，这个状态就是必败态。
若一个状态是必败态，则这个状态连向的所有状态都是必胜态。

预处理完了过后，就可以直接查询输入的情况的结果了。

点击查看代码

#include <bits/stdc++.h>
#define inf32 1e9
#define inf64 2e18
#define ls o << 1
#define rs o << 1 | 1

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;

const int N = 1e5 + 9;

struct Node {
    int xa, ya, xb, yb;
};

int id[10][10][10][10];
Node a[N];
std::vector<int> g[N], h[N];
int cnt[N], ans[N];
std::queue<int> q;

void add(int now, int xa, int ya, int xb, int yb) {
    if(xa > ya)std::swap(xa, ya);
    int nxt = id[xb][yb][xa][ya];

    g[now].push_back(nxt);
    h[nxt].push_back(now);
}

int main()
{
    std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);

    int tot = 0;
    for(int xa = 0;xa <= 9;xa ++) {
        for(int ya = xa;ya <= 9;ya ++) {
            for(int xb = 0;xb <= 9;xb ++) {
                for(int yb = xb;yb <= 9;yb ++) {
                    a[++ tot] = (Node){xa, ya, xb, yb};
                    id[xa][ya][xb][yb] = tot;
                    if(xa == 0 && ya == 0)ans[tot] = 1, q.push(tot);
                    else if(xb == 0 && yb == 0)ans[tot] = 2, q.push(tot);
                }
            }
        }
    }

    for(int xa = 0;xa <= 9;xa ++) {
        for(int ya = std::max(xa, 1);ya <= 9;ya ++) {
            for(int xb = 0;xb <= 9;xb ++) {
                for(int yb = std::max(xb, 1);yb <= 9;yb ++) {
                    int now = id[xa][ya][xb][yb];
                    if(xa) {
                        if(xb)add(now, (xa + xb) % 10, ya, xb, yb);
                        add(now, (xa + yb) % 10, ya, xb, yb);
                    }
                    if(xb)add(now, xa, (ya + xb) % 10, xb, yb);
                    add(now, xa, (ya + yb) % 10, xb, yb);
                }
            }
        }
    }

    while(q.size()) {
        int now = q.front();
        q.pop();
        if(ans[now] == 1) {
            for(auto &i : h[now]) {
                if(!ans[i]) {
                    cnt[i] ++;
                    if(cnt[i] == g[i].size())ans[i] = 2, q.push(i);
                }
            }
        } else {
            for(auto &i : h[now]) {
                if(!ans[i]) {
                    ans[i] = 1;
                    q.push(i);
                }
            }
        }
    }

    int t;std::cin >> t;
    while(t --) {
        int xa, ya, xb, yb;std::cin >> xa >> ya >> xb >> yb;
        if(xa > ya)std::swap(xa, ya);
        if(xb > yb)std::swap(xb, yb);
        std::cout << ans[id[xa][ya][xb][yb]] << '\n';
    }
    return 0;
}

原创作者: TianTianChaoFangDe 转载于: https://www.cnblogs.com/TianTianChaoFangDe/p/18799072