The 2023 ICPC Asia Jinan Regional Contest / The 2nd Universal Cup. Stage 17: Jinan

比赛链接

A. Many Many Heads

题意：给定一个括号序列中每个位置的种类（方/圆），问是否存在唯一的方法定向括号序列，使得其为一个合法的括号序列。

首先可以贪心找出一组解，贪心方法为：维护一个栈，每次遇到一个括号时，若栈顶的括号与它种类相等，那么就把它们匹配为一组，否则就把这个括号种类加入栈顶。

然后就是判断唯一性，若一个合法括号序列有相邻两个种类相同的左括号，例如 ((...))，那么可以调整为 ()...()，即不唯一。当存在 (...)...(...) 时，也可以调整为 (...(...)...)。所以，唯一的合法括号序列只会形如 (S)、[S]、(S)[T] 或 [S](T)，其中 $S,T$ 都为唯一的合法括号序列。复杂度 $\Theta(n)$。

K. Rainbow Subarray

题意：称连续子数组 $a_l,...,a_r$ 是彩虹子数组，若 $a_{i+1}-a_i = 1$。可以进行至多 $k$ 次操作，每次操作可以把一个元素增加或减少 $1$，求操作后最长的彩虹子数组。

设一个合法数组的首项为 $t$，那么它肯定长的形如 $t,t+1,...$，即第 $i$ 项为 $t+i-1$，那么在圆序列中合法的 $a[l...r]$ 就对应 $a_i = t+i-l(i \in [l,r])$，那么把 $a_i$ 变为 $t+i-l$ 的代价就是 $|(a_i - i) - (l-t) |$，设 $b_i = a_i - i,t' = l - t$，那么代价就是 $\min\limits_{t'} \sum\limits_{i=l}^r |b_i - t'|$，显然 $t'$ 为 $b_i$ 的中位数时最小。

考虑做个双指针，维护 $[l,r]$ 区间的值域，每次找到中位数，分别求出小于中位数和大于中位数的 $sum$ 和 $cnt$ 即可，看看代价是否 $\le k$。用线段树维护，复杂度 $\Theta(n\log n)$。

M. Almost Convex Polygon

显然 $|R|$ 最小时即为凸包点数，那么先把凸包求出来，然后对于每个非凸包上的点 $u$ 看看凸包上每条相邻边 $(p_i,p_{i+1})$ 是否能连向它，即 $(u,p_i,p_{i+1})$ 三个点组成的三角形中是否有其他点。

考虑枚举点 $u$，然后对于其他所有点 $v \neq u$，设向量 $a_v = v - u$，然后对 $a_i$ 极角排序，若对于 $(p_i,p_{i+1})$ 在排序后 $(a_{p_i},a_{p_{i+1}})$ 也相邻，那么它就合法。

复杂度 $\Theta(n^2 \log n)$，注意不要在排序函数中求 atan2，常数巨大。

E. I Just Want... One More...

题意：给定一张平衡二分图。您需要添加恰好一条边，连接 $U$ 中的一个节点与 $V$ 中的一个节点，使得图的匹配数增加。求方案数。

考虑先跑一遍流求出一组最大匹配出来。然后若连边 $(u,v)$ 考虑它们合法的情况，即 $u$ 为非匹配点或能够成功增广 $match_u$，$v$ 同理。那么就是要求出有哪些点是可以成功增广的。

从二分图的角度来看，可以先标记每个非匹配点 $u$。对于每个标记点 $u$，若存在边 $(u,v)$，且 $v$ 为匹配点，那么也标记 $match_v$，最后答案就是左边被标记的点数和右边被标记的点数乘积。

从网络流的角度来看，直接从 $S$ 出发在残量网络中找到左边所有能到达的点，和从 $T$ 出发找到右边能到达的点，两者个数乘积即为答案。两种方法并无本质差别。

复杂度 $\Theta(m\sqrt{n})$。

B. Graph Partitioning 2

题意：给一棵 $n$ 个点的树，求联通块划分的方案数使得每个联通块大小 $\in \{ k,k+1\}$。

划分可以考虑根号分治。

• 若 $k \le \sqrt{n}$，直接做树形背包，设 $f_{u,i}$ 为 $u$ 子树中 $u$ 所在联通块大小为 $i$ 方案数，转移 $\Theta(nk)$。

• 若 $k > \sqrt{n}$，那么此时联通块个数为 $\Theta(\sqrt{n})$ 级别，那么若设 $f_{u,i,j}$ 为 $u$ 子树中有 $i$ 个 $k$ 联通块，$j$ 个 $k+1$ 联通块，复杂度为 $\Theta(n^2)$ 不可接受。注意到 $ik + j(k+1) = siz_u$，那么只需要记录 $i$ 就行，为了方便转移，多加一维 $0/1$ 表示 $u$ 所在联通块大小是否为 $k+1$，那么状态即为 $f_{u,i,0/1}$。

  • 通过计算显然可以得出当前 $u$ 所在联通块大小为 $siz_u - ik - (k+1)\lfloor \dfrac{siz_u - ik}{k+1} \rfloor$。若第三维是 $1$，那么大小就为 $k+1$。

  • 加入子树 $v$ 时，设 $u,v$ 联通块大小为 $x,y$（当第三维是 $1$ 时。

    • 若 $x = k+1, y = k + 1$，有 $f_{u,i,1} \times f_{v,j,1} \to f'_{u,i+j,1}$。
    • 若 $x = k+1, y = 0$，有 $f_{u,i,1} \times f_{v,j,0} \to f'_{u,i+j,1}$。
    • 若 $x \le k, y = k + 1$，有 $f_{u,i,0} \times f_{v,j,1} to f'_{u,i+j,0}$。
    • 若 $x + y = k + 1$，有 $f_{u,i,0} \times f_{v,j,0} \to f'_{u,i+j,1}$
    • 若 $x + y \le k$，有 $f_{u,i,0} \times f_{v,i,0} \to f'_{u,i+j,0}$。

  • 结束合并后，对于 $x=k$ 的状态 $f_{u,i,0}$ 可以有转移 $f_{u,i+1,0} \leftarrow f_{u,i+1,0} + f_{u,i,0}$，表示结束 $u$ 这个联通块的拓展。

复杂度 $\Theta(n\sqrt{n})$。

#include <bits/stdc++.h>
#define _rep(i, x, y) for(int i = x; i <= y; ++i)
#define _req(i, x, y) for(int i = x; i >= y; --i)
#define _rev(i, u) for(int i = head[u]; i; i = e[i].nxt)
#define pb push_back
#define fi first
#define se second
#define mst(f, i) memset(f, i, sizeof f)
using namespace std;
#ifdef ONLINE_JUDGE
#define debug(...) 0
#else
#define debug(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#endif
typedef long long ll;
typedef pair<int, int> PII;
namespace fastio{
    #ifdef ONLINE_JUDGE
    char ibuf[1 << 20],*p1 = ibuf, *p2 = ibuf;
    #define get() p1 == p2 && (p2 = (p1 = ibuf) + fread(ibuf, 1, 1 << 20, stdin), p1 == p2) ? EOF : *p1++
    #else
    #define get() getchar()
    #endif
    template<typename T> inline void read(T &t){
        T x = 0, f = 1;
        char c = getchar();
        while(!isdigit(c)){
            if(c == '-') f = -f;
            c = getchar();
        }
        while(isdigit(c)) x = x * 10 + c - '0', c = getchar();
        t = x * f;
    }
    template<typename T, typename ... Args> inline void read(T &t, Args&... args){
        read(t);
        read(args...);
    }
    template<typename T> void write(T t){
        if(t < 0) putchar('-'), t = -t;
        if(t >= 10) write(t / 10);
        putchar(t % 10 + '0');
    }
    template<typename T, typename ... Args> void write(T t, Args... args){
        write(t), putchar(' '), write(args...);
    }
    template<typename T> void writeln(T t){
        write(t);
        puts("");
    }
    template<typename T> void writes(T t){
        write(t), putchar(' ');
    }
    #undef get
};
using namespace fastio;
#define multitest() int T; read(T); _rep(tCase, 1, T)
namespace Calculation{
    const ll mod = 998244353;
    ll ksm(ll p, ll h){ll base = p % mod, res = 1; while(h){if(h & 1ll) res = res * base % mod; base = base * base % mod, h >>= 1ll;} return res;}
    void dec(ll &x, ll y){x = ((x - y) % mod + mod) % mod;}
    void add(ll &x, ll y){x = (x + y) % mod;}
    void mul(ll &x, ll y){x = x * y % mod;}
    ll sub(ll x, ll y){return ((x - y) % mod + mod) % mod;}
    ll pls(ll x, ll y){return ((x + y) % mod + mod) % mod;}
    ll mult(ll x, ll y){return x * y % mod;}
}
using namespace Calculation;
const int N = 1e5 + 5, B = 300, M = 405;
int n, k, siz[N];
vector<int> G[N];
namespace solution1{
    ll f[N][M], g[M];
    void dfs(int u, int fa){
        f[u][1] = 1, siz[u] = 1;
        for(auto &v : G[u]){
            if(v == fa) continue;
            dfs(v, u);
            _rep(i, 1, min(siz[u], k + 1)) _rep(j, 0, min(siz[v], k + 1 - i)){
                add(g[i + j], f[u][i] * f[v][j] % mod);
            }
            siz[u] += siz[v];
            _rep(i, 0, min(siz[u], k + 1)) f[u][i] = g[i], g[i] = 0;
        }
        add(f[u][0], f[u][k] + f[u][k + 1]), f[u][k + 1] = 0;
    }
    void solve(){
        dfs(1, 0);
        writeln(f[1][0]);
        _rep(i, 1, n) _rep(j, 0, k + 1) f[i][j] = 0; 
        _rep(i, 1, n) G[i].clear(), siz[i] = 0;
    }
}
namespace solution2{
    ll f[N][M][2], g[M][2];
    void dfs(int u, int fa){
        f[u][0][0] = 1, siz[u] = 1;
        for(auto &v : G[u]){
            if(v == fa) continue;
            dfs(v, u);
            _rep(i, 0, siz[u] / k) _rep(j, 0, siz[v] / k){
                _rep(p, 0, 1) _rep(q, 0, 1){
                    int x = (siz[u] - i * k) / (k + 1) - p, y = (siz[v] - j * k) / (k + 1) - q;
                    x = siz[u] - (k + 1) * x - i * k, y = siz[v] - (k + 1) * y - j * k;
                    if(x){
                        if(!p && !q && x + y == k + 1){
                            add(g[i + j][1], f[u][i][p] * f[v][j][q]);
                        }
                        if(p){
                            if(q || !y) add(g[i + j][1], f[u][i][p] * f[v][j][q]);
                        }
                        if(!p){
                            if(q) add(g[i + j][0], f[u][i][p] * f[v][j][q]);
                            if(!q && x + y <= k){
                                add(g[i + j][0], f[u][i][p] * f[v][j][q]);
                            }
                        }
                    }
                }
            }
            siz[u] += siz[v];
            _rep(i, 0, siz[u] / k) _rep(p, 0, 1) f[u][i][p] = g[i][p], g[i][p] = 0;
        }
        _rep(i, 0, siz[u] / k) if((siz[u] - i * k) % (k + 1) == k) add(f[u][i + 1][0], f[u][i][0]); 
    }
    void solve(){
        dfs(1, 0);
        ll ans = 0;
        _rep(i, 0, n / k){
            _rep(j, 0, 1){
                if(j || (n - i * k) % (k + 1) == 0) add(ans, f[1][i][j]);
            }
        }
        writeln(ans);
        _rep(i, 1, n) _rep(j, 0, n / k) _rep(p, 0, 1) f[i][j][p] = 0; 
        _rep(i, 1, n) G[i].clear(), siz[i] = 0;
    }
}
int main(){
    multitest(){
        read(n, k);
        _rep(i, 2, n){
            int u, v; read(u, v);
            G[u].pb(v), G[v].pb(u);
        }
        if(k <= B) solution1::solve();
        else{
            solution2::solve();
        }
    }    
    return 0;
}

H. Basic Substring Structure

题意：给定字符串 $s$，求对于每个 $i$ 求出更改 $s_i=j(j \neq s_i)$ 后 $z_i = lcp(suf_i,s)$ 之和的最大值。

直接分讨，先特殊处理位置 $1$，设 $r_i=i+z_i - 1$。

再设 $f_i$ 为把 $s_{r_i + 1}$ 更改为 $s_{z_i + 1}$ 后的 $z'_i - z_i$，$g_i$ 为把 $s_{z_i + 1}$ 更改为 $s_{r_i + 1}$ 后的 $z'_i - z_i$。

分类讨论贡献：

设将 $s_i \leftarrow c$ 后

• 减的贡献：
  • 对于 $j\le i,r_j \ge i$，贡献 $r_j - i+1$。
  • 对于 $j > i, z_j \ge i$，贡献 $z_j - i + 1$。
• 加的贡献：
  • 对于 $j \le i,r_j = i - 1, s_{z_j + 1} = c$，贡献 $f_j$。
  • 对于 $j>i,z_j = i - 1, s_{r_j + 1} = c$，贡献 $g_j$。

$z_i,f_i,g_i$ 显然都可以通过 SA 求 $lcp$ 求出。然后对于 $s_i$，有用的 $c$ 值域加的贡献中的 $s_{z_j + 1}$ 和 $s_{r_j + 1}$，每个 $s_{z_j + 1}$ 和 $s_{r_j + 1}$ 只可能贡献到一种 $i$，所以直接暴力枚举，然后扫描线处理一下 $j \le i$ 和 $j>i$ 的位置关系即可。

复杂度 $\Theta(n\log n)$。

L. Ticket to Rid

题意：有 $(n+1)$ 个点排成一条线，编号从 $0$ 到 $n$。还有 $n$ 条线段，第 $i$ 条线段连接点$(i−1)$ 和 $i$。给定 $q$ 个区间 $[li,ri]$，每个区间还有一个分数 $v_i$。可以选择将一些线段涂红，如果点 $l_i$ 到 $r_i$ 之间的线段都是红的，那么得 $v_i$ 分。求恰好涂红 $1,2,··· ,n$ 条线段的最大得分。

设 $f_{i,j},g_{i,j}$ 为前 $i$ 个线段涂完 $j$ 个最后一个是否涂的最大贡献。

转移有 $g_{i,j} = \max(g_{i-1,j},f_{i-1,j})$，$f_{i,j} = \max\limits_{k<i} g_{k,j-i+k}+w(k,i)$，其中 $w(l,r)$ 为完全被包含在 $[l,r]$ 中的区间价值和。注意到令第二维 $j' = i-j$，有 $f_{i,j'} = \max\limits_{k<i} g_{k,j'} + w(k,i)$，那么可以先枚举一个 $j'$，再枚举一个 $i$ 转移。

下面先忽略第二位 $j'$。

考虑扫描线优化转移，当 $i$ 为某个区间的右端点时，把 $w_i \leftarrow w_i + v_j(l_j \ge i)$，然后更新完 $g_{i}$ 时，令 $w_i = g_{i}$，然后 $f_i$ 就是 $w_{0},...w_{i-1}$ 的最大值。线段树可以做到 $\Theta(n^2\log n)$，但无法通过。考虑到只用看前缀最大值，那么不妨使用并查集维护每个前缀最大值相等的连续段，然后设 $h_i$ 为下一个段的值减去当前段的值，每次前缀加 $v$ 时找到 $l$ 所在的段，把 $h_i$ 和 $v$ 同时减去 $\min(v,h_i)$，若 $h_i =0$，往后合并即可。每次往后面插一个数只需判断是否比前面的最大值大即可。实现上就是维护第一个段的值和每个段的差分即可。

注意先枚举 $j'$ 只用记录 $j' - 1, j'$ 的 $f,g$，空间可以压缩到 $\Theta(n+m)$。

时间复杂度 $\Theta(n(n+m)\alpha(n))$

F. Say Hello to the Future

题意：有一个长度为 $n$ 的序列 $a$，你需要将它划分为若干个区间，满足对于每个 $i$，它所在的区间长度 $\ge a_i$。对于每个 $i$ 求出将 $a_i$ 变成 $1$ 后方案数。

首先考虑直接求一个序列的方案数，设 $f_i$ 为最后一段结尾 $i$ 方案数，转移即为 $f_i = \sum\limits_{j<i} f_j [\max\limits_{k=j+1}^i a_k \le i-j]$。

考虑分治转移，对于 $j \in [l,mid]$ 的 $f_j$ 对 $i \in [mid + 1, r]$ 的 $f_i$ 的贡献。找到 $[j,mid]$ 的最大值 $lmax_j$，它只对 $i \ge \max(mid + 1, j+lmax_j - 1)$ 的 $i$ 有贡献，对于 $[mid,i]$ 的最大值 $rmax_i$，$f_i$ 只会接受 $j \le \min(mid,i-rmax_i + 1)$ 的贡献，把 $f_j$ 插到 $j+lmax_j - 1$ 后对右边扫描线树状数组维护即可，复杂度 $\Theta(n\log^2 n)$。

考虑对于前缀和后缀都求出这个方案 $f_i,g_i$。然后考虑更改的贡献。若更改了 $a'_x = 1$，那么对于分治区间 $x \in [l,r]$，不妨假设 $x \in [l,mid]$，那么对于 $i \in [l,x]$，若 $lmax_i=a_x$，设次大值 $lmax2_i$，那么会多接受 $[i+lmax2_i-1,i+lmax_i-2]$ 这段区间中 合法 的 $g_j$ 的贡献（合法就是 $j$ 也能贡献到 $i$ 这个位置，同样可以用上面的扫描线求）。那么把这个贡献 $cur$，多加到所有 $x \in [i,mid],a_x = lmax_i$ 的 $ans_x$ 中即可。

$x \in [mid + 1,r]$ 同理，复杂度 $\Theta(n\log^2 n)$。