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";
}