AtCoder Beginner Contest 214 （D并查集，E反悔贪心，F公共子序列DP）

题目链接：Here

ABC水题，

D - Sum of Maximum Weights

上图中最大权 \(9\) 对答案的贡献是这条边两边的连通块的 size 的乘积再乘以 9

受到上面的启发，我们可以把每条边按边权大小从小到大排序。对于每条边（边权记为 \(w\)），先求出当前边连接的两个 group 的 size，不妨记为 \(size_a\) 和 \(size_b\) ，再把 \(size_a \times size_b \times w\) 累加后合并两个连通块(并查集)

这里偷懒用一下 atcoder 的库函数写。

#include <bits/stdc++.h>

#include <atcoder/all>

using namespace std;

using namespace atcoder;

int main() {

    int n;

    cin >> n;

    vector<tuple<long long, int, int>> p(n - 1);

    for (auto &[w, u, v] : p) {

        cin >> u >> v >> w;

        u--; v--;

    }

    sort(p.begin(), p.end());

    long long ans = 0;

    dsu uf(n);

    for (auto [w, u, v] : p) {

        if (!uf.same(u, v)) {

            ans += w * uf.size(u) * uf.size(v);

            uf.merge(u, v);

        }

    }

    cout << ans << endl;

    return 0;

}

E - Packing Under Range Regulations

题意理解来自 Ncik桑

本题显然是区间调度问题(反悔贪心问题)，和以下问题等价：

有 \(N\) 个工作。第 \(i\) 个工作可以从 \(L_i\) 日开始，截止日期为 \(R_i\) 日。任何一项工作都可以在一天内完成，一天最多只能完成一项工作。你能在截止日期前完成所有工作吗？

显而易见的，我们应该从最紧急的工作开始，即把任务按 \(L\) 从大到小排列然后用优先级队列按 \(R\) 的大小顺序检索 “你现在可以做的任务 “来模拟这种情况。

const int inf = 1001001001;

void solve() {

    int n; cin >> n;

    vector<pair<int, int>> a(n);

    for (auto &[u, v] : a) cin >> u >> v;

    sort(a.begin(), a.end());

    priority_queue<int, vector<int>, greater<int>>q;

    int x = 1;

    a.push_back({inf, inf});

    for (auto [l, r] : a) {

        while (x < l && q.size()) {

            if (q.top() < x) {

                cout << "No\n";

                return ;

            }

            q.pop(); x += 1;

        }

        x = l; q.push(r);

    }

    cout << "Yes\n";

}

F - Substrings

首先，让我们考虑不受相邻字符不同时选择的约束的问题。

查找S的非空子字符串的数目。在这里，子字符串是在删除0个或更多字符的情况下不重新排序原始字符串的串联。

在这里，重要的是不同的删除方式可能会导致相同的子字符串。这里会用“公共子序列DP”的方法解决问题，在该方法中，子字符串的计数不包含那些重复项。

考虑下面的DP。

考虑下面的DP

\(dp_i\):= 字符串中第 \(1\) 个到第 \(i\) 个字符串的数目，

定义 \(dp_{p_0} = 1\) 对应于一个空字符串。转换可以写为以下内容：

\(dp_i = \sum_{j = 0}^{i - 1}dp_j\)

但可能会多次计算相同子字符串，所以稍微修改一下

\(dp_i = \sum_{j = k}^{i - 1}dp_j\) ，其中 \(k\) 为最大整数使得 \(S_i = S_k\ (k < i)\) 如果没有这样的整数则 \(k = 0\)

直观地说，如果 \(S_k = S_i\) ，那么我们禁止在某些 \(j(<k)\)的 \(S_j\) 后面追加 \(S_i\) ，因为这没有意义（我们可以在 \(S_j\) 后面追加 \(S_k\)），这样就避免了重复。事实上，这是计算所有不重复的子字符串所需的唯一扭曲。

乍一看，复杂度看起来像 \(\mathcal{O}(|S|^2)\)，但实际上，借助累积和，它可以总共执行 \(\mathcal{O}(|S|)\)，或者在没有累积和的情况下执行 \(\mathcal{O}(σ|S|)\)，其中 \(σ\) 表示不同字母的数量，这足够快了。

这个想法也可以应用于原始问题。设 \(dp_0 = 1\) 和 \(dp_1=0\) 。

递归关系可以写成：\(dp_{i+1} = \sum_{j = k}^{i - 1}dp_j\) ，其中 \(k\) 是最大整数，使得 \(S_i=S_k\) 和 \(k<i\)（如果没有这样的整数，则 \(k=0\) ）

const int mod = 1e9 + 7;

int main() {

    cin.tie(nullptr)->sync_with_stdio(false);

    string s; cin >> s;

    int n = s.size();

    vector<ll> f(n + 2); f[0] = 1;

    for (int i = 0; i < n; ++i)

        for (int j = i - 1;; j--) {

            f[i + 2] = (f[i + 2] + f[j + 1]) % mod;

            if (j == -1 || s[j] == s[i]) break;

        }

    ll ans = 0;

    for (int i = 2; i < n + 2; i++) ans += f[i];

    cout << ans % mod << "\n";

}