2024牛客多校 4 （概率，带权并查集，构造）

2024牛客多校 4 （概率，带权并查集，构造）

J - Zero

题面：给出整数 $n$ 和 $k$ ， 一个 0 1 ? 字符串 $s$ 。

? 有概率是 0 或是 1，且概率相等，一段区间 $[l,r]$ 的贡献这样计算：

• 这一段区间不包含 0

• 贡献为长度的 $k$ 次方

求这个字符串 $s$ 的期望贡献是多少？

solution：

首先应该考虑如何统计贡献，如果遍历区间，到达了复杂度 $O(n^2)$ 复杂度。

于是自然想到统计每一位的贡献，开始想到统计第 $i$ 位出现的所有区间的贡献，但尝试过之后发现难以实现，重点来了，计算第 $i$ 位结尾所得的贡献。

$dp[i]$ 表示第 $i$ 位结尾所得的贡献 ，于是列式计算：

若子串为 ????

则 $f[3]$ 表示为 ${\frac{1}{2}}^1\ast 1^k+{\frac{1}{2}}^2\ast 2^k+{\frac{1}{2}}^3\ast 3^k$

$f[4]=$ ${\frac{1}{2}}^1\ast 1^k+{\frac{1}{2}}^2\ast 2^k+{\frac{1}{2}}^3\ast 3^k+{\frac{1}{2}}^4\ast 4^k$

自然想到如何从 $f[3]$ 变化到 $f[4]$ ，这个时候联想一下数组推移的样子，首先多了一项长度为 1 的，其次前面每一项都长度加 1 ，用 $f[4]$ 减去 $f[3]$ 可得一个简单的式子：

$$(x+1{)}^k-x^k=\sum _{i=0}^{k-1}{C}_k^i\ast x^i$$

所以发现需要计算 $k$ 次方的答案需要用到 0 - (k - 1) 的结果，于是升级定义

定义 $dp[i][j]$ 表示第 $i$ 位结尾，$k=j$ 时的贡献

细节为底层特殊情况应该需要特殊判断去赋值，然后递推公式就是：

$$dp[i][j]=\{\begin{array}{r}dp[i-1][j]+1+\sum _{i=0}^{k-1}{C}_k^i\ast dp[i-1][i],s[i]=1\\ \frac{1}{2}\ast (dp[i-1][j]+1+\sum _{i=0}^{k-1}{C}_k^i\ast dp[i-1][i]),s[i]=?\end{array}$$

参考代码如下：

// Created by qyy on 2024/9/13.

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define PII pair<int, int>
#define endl "\n"

const long long inf = 0x3f3f3f3f3f3f3f3f;
const int N = 2e5 + 10;
const long long mod = 998244353;

int n, k;
ll dp[N][32];
string s;

ll fast_pow(ll a, ll n){
    ll ans = a % mod;
    while(n){
        if(n & 1){
            ans = (ans * a) % mod;
        }
        a = (a * a) % mod;
        n >>= 1;
    }
    return ans;
}
ll inv(ll x){
    return fast_pow(x, mod - 2);
}

ll C[50][50];


ll cal(int beg, int ed){
    if(beg > ed){
        return 0;
    }
    int len = ed - beg + 1;
    for(int i = 0; i <= len; i++){
        for(int j = 0; j <= 30; j++){
            dp[i][j] = 0;
        }
        if(i != 0){
            dp[i][0] = 1;
        }
    }

    ll ans = 0;
    if(s[beg] == '?'){
        dp[1][0] = inv(2);
    }else{
        dp[1][0] = 1;
    }
    for(int j = 1; j <= k; j++){
        dp[1][j] = dp[1][j - 1];
    }
    for(int j = 0; j <= k; j++){
        for(int i = 2; i <= len; i++){
            int pos = beg + i - 1;
            ll res = 1;
            for(int x = 0; x < j; x++){
                ll tmp = C[j][x] * dp[i - 1][x];
                res = (res + tmp) % mod;
            }
            res = (res + dp[i - 1][j]) % mod;
            if(s[pos] == '?'){
                dp[i][j] = (res * inv(2)) % mod;
            }else{
                dp[i][j] = res;
            }
        }
    }
    for(int i = 1; i <= len; i++){
        ans = (ans + dp[i][k]) % mod;
    }
    return ans;
}

void solve() {
    cin >> n >> k;
    cin >> s;

    for(int i = 1; i <= 40; i++){
        C[i][0] = C[i][i] = 1;
        for(int j = 1; j < i; j++){
            C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
        }
    }
    s.push_back('0');
    int len = s.size();
    int beg = 0, ed = 0;
    ll ans = 0;
    for(int i = 0; i < len; i++){
        if(s[i] == '0'){
            ed = i - 1;
            ans = (ans + cal(beg, ed)) % mod;
            beg = i + 1;
        }
    }
    cout << ans % mod << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

---

A - LCT

题面：在一个连接成 $n$ 个节点的树的过程中，询问当前任意一个根节点的最大深度是多少。

solution：显然用带权并查集来解决......

回顾 P1196 银河超级英雄，维护并查集中各点对根节点的距离。

P1196细节：

    int find_set(int x){
        int tmpfa = fa[x];
        if(fa[x] != x){
            fa[x] = find_set(fa[x]); // 先把当前父亲节点的更新了，再去计算
            dp[x] += dp[tmpfa];
        }
        return fa[x];
    }

需要先更新了当前父节点的状态才能推来，有点 $dp$ 的感觉

---

于是此题可以同样维护距离根节点距离数组，再针对根节点维护一个最大深度数组，于是考虑两个函数各自应该更新什么。

find_set(x) 应该路径压缩中，将当前根节点的答案累计到该点上。

merge_set(x, y) 应该增加 x 根节点的深度与更新 y 所在根节点的答案。

参考代码如下：

// Created by qyy on 2024/9/13.

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define PII pair<int, int>
#define endl "\n"

const long long inf = 0x3f3f3f3f3f3f3f3f;
const int N = 1e6 + 10;
const int mod = 7;

int n;
int fa[N], cnt[N], dp[N], ans[N];
void dsu_init(){
    for(int i = 1; i <= n; i++){
        fa[i] = i;
        cnt[i] = 1;
        dp[i] = 0;
        ans[i] = 0;
    }
}
int find_set(int x){
    int tmpfa = fa[x];
    if(fa[x] != x){
        fa[x] = find_set(fa[x]);
        dp[x] += dp[tmpfa];
    }
    return fa[x];
}
void merge_set(int x, int y){
    int fx = find_set(x), fy = find_set(y);
    if(fx != fy){
        ans[fy] = max(ans[fy], ans[fx] + dp[y] + 1);
        dp[x] += dp[y] + 1; // 链上的加法
        fa[fx] = fy;
    }
}
void solve() {
    cin >> n;
    dsu_init();
    for(int i = 1; i < n; i++){
        int a, b, c;
        cin >> a >> b >> c;
        merge_set(b, a);
        cout << ans[c] << " ";
    }
    cout << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}