AtCoder Beginner Contest 383 E、F

最新推荐文章于 2025-08-25 13:37:23 发布

原创最新推荐文章于 2025-08-25 13:37:23 发布 · 1k 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法

AtCoder Beginner Contest 383 E、F

E - Sum of Max Matching

分析

首先明确题目的定义：

路径长度：从 $x$ 到 $y$ 简单路径上最大的边权即为该路径长度
$f (x, y)$ ：从 $x$ 到 $y$ 的最小路径长度

因为题目给的两个 $A$ 、 $B$ 序列里元素不存在相等的，也就是划分成了两个点集
最后要你可以随意排序，得到最小的 $\sum_{i=1}^{K} f(A_{i},B_{i})$
这是一类很经典的问题，给定一些询问，在 $x$ 和 $y$ 之间有很多路径，要你找到最小的那一条或他们的和最小
首先要想到的是 $x$ 和 $y$ 之间可能存在很多路径，基于贪心的思想，那肯定是最大的边权越小越好，因此把所有边先按照边权大小进行排序。假设当前的每一个点都是独立的点，根据Kruskal求最小生成树的方法，把边两端的点依次加到集合里，这样在确保 $x$ 能走到 $y$ 的前提下，也保证了当前的简单路径上的边权一定都是最小的
基于上述思考，那么问题仿佛就迎刃而解了。
令 $e d g e [i] [0]$ 为边权， $e d g e [i] [1]$ 和 $e d g e [i] [2]$ 为边连接的两个点， $a$ 和 $b$ 数组分别记录序列 $A$ 和 $B$ 中编号为 $i$ 的点的个数
这里把所有的点都存在一个并查集里，但每个集合的个数还是按照 $A$ 和 $B$ 分别记录，方便我们计算。值得注意的是，尽管 $A$ 和 $B$ 的点都连在一个并查集里，我们还要考虑的是连了当前这条边，会产生三种情况

把 $A$ 集合里的两个点连在了一起
把 $B$ 集合里的两个点连在了一起
把 $A$ 集合里的一个点和 $B$ 集合里的一个点连在了一起

第一种和第二种情况并不会产生代价，而第三种则会产生 $当前边权 * min (a [f b], b [f b])$ 的代价，最后要把计算过的点从 $a$ 和 $b$ 数组中删除，保证 $a [f b]$ 和 $b [f b]$ 中至少有一个是0

代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, m, k;
    cin >> n >> m >> k;
    vector<array<int, 3>> edge(m);
    for (int i = 0; i < m; i++) {
        cin >> edge[i][1] >> edge[i][2] >> edge[i][0];
    }
    vector<int> f(n + 1), a(n + 1), b(n + 1);
    for (int i = 1, x; i <= k; i++) {
        cin >> x;
        a[x]++;
    }
    for (int i = 1, x; i <= k; i++) {
        cin >> x;
        b[x]++;
    }
    iota(f.begin(), f.end(), 0);
    sort(edge.begin(), edge.end());
    auto getfa = [&](int x, auto &&self) -> int {
        return x == f[x] ? x : f[x] = self(f[x], self);
    };
    LL ans = 0;
    for (int i = 0; i < m; i++) {
        int fa = getfa(edge[i][1], getfa), fb = getfa(edge[i][2], getfa);
        if (fa != fb) {
            f[fa] = fb;
            a[fb] += a[fa];
            b[fb] += b[fa];
            int minn = min(a[fb], b[fb]);
            a[fb] -= minn;
            b[fb] -= minn;
            ans += 1LL * minn * edge[i][0];
        }
    }
    cout << ans << '\n';
    return 0;
}

F - Diversity

分析

根据题意不难发现，每种物品只有选与不选，需要记录的状态有：物品颜色的种类、物品颜色的价值，要求的最大值是所有物品的 $\sum utility + K * (物品颜色种类)$
其中设 $a [i] [0]$ 为物品颜色， $a [i] [1]$ 为物品价格， $a [i] [2]$ 为物品的 $u t i l i t y$ ，不难发现的是如果选过了当前颜色，那么价值就是 $a [i] [2]$ ，如果没选过当前颜色，价值就是 $K + a [i] [2]$
可以先设一个 $d p$ 方程，令 $d p [i] [j]$ 为前 $i$ 个物品里面，一共拿了价值为 $j$ 的物品的最大价值，但发现这里面少了一维，没法记录当前有多少种颜色数，但现在空间复杂度已经到了 $O (n x)$ ，因为只需要颜色种类个数，而不需要知道拿了哪些颜色，所以可以根据颜色进行排序，再在 $d p$ 数组添加一维 $0/1$ 表示当前这种颜色拿没拿过，即 $d p [i] [j] [k (0/1)]$
转移方程先考虑如果当前第 $i$ 个物品不拿，那么显然
$d p [i] [j] [0] = ma x (d p [i] [j] [0], d p [i - 1] [j] [0])$
再考虑如果前面一个物品的颜色和当前物品的颜色一样的话，不难得到
$d p [i] [j] [1] = ma x (d p [i] [j] [1], d p [i - 1] [j] [1])$
最后考虑如果前面一个物品和当前物品颜色不一样，得到
$d p [i] [j] [0] = ma x (d p [i] [j] [0], d p [i - 1] [j] [1])$
因此，如果当前第 $i$ 个物品我们不拿，那么更新答案 $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots], dp[i][j][1])$
再考虑拿当前第 $i$ 个物品，显然有
$d p [i] [j] [1] = ma x (d p [i] [j] [1], d p [i - 1] [j - a [i] [1]] [0] + a [i] [2] + K)$
再考虑如果前面一个物品和当前物品的颜色一样的话，不难得到
$d p [i] [j] [1] = ma x (d p [i] [j] [1], d p [i - 1] [j - a [i] [1]] [1] + a [i] [2])$
否则一定会多出一种颜色种数
$d p [i] [j] [1] = ma x (d p [i] [j] [1], d p [i - 1] [j - a [i] [1]] [1] + K + a [i] [2])$
再更新答案即可

代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
array<int, 3> a[510];
LL dp[510][50010][2];
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, x, K;
    cin >> n >> x >> K;
    for (int i = 1; i <= n; i++) {
        cin >> a[i][1] >> a[i][2] >> a[i][0];
    }
    sort(a + 1, a + 1 + n);
    dp[1][a[1][1]][1] = K + a[1][2];
    LL ans = dp[1][a[1][1]][1];
    for (int i = 2; i <= n; i++) {
        for (int j = 0; j <= x; j++) {
            dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][0]);
            if (a[i][0] != a[i - 1][0]) {
                dp[i][j][0] = max(dp[i][j][0], dp[i - 1][j][1]);
            } else {
                dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j][1]);
            }
            ans = max({ans, dp[i][j][0], dp[i][j][1]});
        }
        for (int j = a[i][1]; j <= x; j++) {
            dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j - a[i][1]][0] + K + a[i][2]);
            if (a[i][0] == a[i - 1][0]) {
                dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j - a[i][1]][1] + a[i][2]);
            } else {
                dp[i][j][1] = max(dp[i][j][1], dp[i - 1][j - a[i][1]][1] + K + a[i][2]);
            }
            ans = max({ans, dp[i][j][1], dp[i][j][0]});
        }
    }
    cout << ans << '\n';
    return 0;
}

~~保研结束后宕机了两个月~~，继续训起来，后续也会更新一些技术学习笔记