AtCoder-ABC-Ex乱写

ABC233Ex Manhattan Christmas Tree

先将 $(x,y)$ 变成 $(x+y,x-y)$，也就是曼哈顿转切比雪夫，之后曼哈顿距离 $\le k$ 的在切比雪夫坐标系下就是一个正方形。

用主席树做矩形和，外层套一个二分即可，时间复杂度 $\mathcal{O}(n{\log }^{2}n)$。

ABC233Ex

#include <bits/stdc++.h>

using namespace std;

struct Point {
    int x, y;
    Point(int _x = 0, int _y = 0): x(_x), y(_y) {}
};
bool operator < (const Point &lhs, const Point &rhs) 
    {return lhs.x != rhs.x ? lhs.x < rhs.x : lhs.y < rhs.y; }

const int N = 1e5 + 10, INF = 0x3f3f3f3f;
int n; Point P[N];
vector<int> lsh[2];

namespace SegTree {
    const int M = 3e6 + 10;
    int root[N], tot = 0;
    int lc[M], rc[M], C[M];
    inline int New() {++tot; lc[tot] = rc[tot] = C[tot] = 0; return tot; }
    inline void maintain(int u) {C[u] = C[lc[u]] + C[rc[u]]; }
#define mid ((l + r) >> 1)
    void Add(int &shadow, int &u, int l, int r, int p, int x) {
        u = New(); lc[u] = lc[shadow], rc[u] = rc[shadow], C[u] = C[shadow];
        if(l == r) {C[u] += x; return; }
        if(p <= mid) Add(lc[shadow], lc[u], l, mid, p, x);
        else Add(rc[shadow], rc[u], mid + 1, r, p, x);
        maintain(u);
    }
    int Ask(int u, int l, int r, int L, int R) {
        if(!u) return 0;
        if(l >= L && r <= R) return C[u];
        if(mid >= R) return Ask(lc[u], l, mid, L, R);
        else if(mid < L) return Ask(rc[u], mid + 1, r, L, R);
        else return Ask(lc[u], l, mid, L, R) + Ask(rc[u], mid + 1, r, L, R);
    }
#undef mid
}

inline bool check(int x, int y, int mid, int k) {
    int siz = 0;
    int l, r; l = upper_bound(lsh[1].begin(), lsh[1].end(), y - mid - 1) - lsh[1].begin() + 1;
    r = upper_bound(lsh[1].begin(), lsh[1].end(), y + mid) - lsh[1].begin();
    int p = upper_bound(P + 1, P + n + 1, Point(x + mid, INF)) - P - 1;
    siz += SegTree::Ask(SegTree::root[p], 1, n, l, r);
    p = upper_bound(P + 1, P + n + 1, Point(x - mid - 1, INF)) - P - 1;
    siz -= SegTree::Ask(SegTree::root[p], 1, n, l, r);
    return siz >= k;
}

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n;
    for(int i = 1; i <= n; i ++) {
        int x, y; cin >> x >> y;
        P[i].x = x + y, P[i].y = x - y;
        lsh[0].emplace_back(x + y), lsh[1].emplace_back(x - y);
    }
    sort(lsh[0].begin(), lsh[0].end()), sort(lsh[1].begin(), lsh[1].end());
    lsh[0].erase(unique(lsh[0].begin(), lsh[0].end()), lsh[0].end());
    lsh[1].erase(unique(lsh[1].begin(), lsh[1].end()), lsh[1].end());

    sort(P + 1, P + n + 1);
    for(int i = 1; i <= n; i ++) 
        P[i].y = lower_bound(lsh[1].begin(), lsh[1].end(), P[i].y) - lsh[1].begin() + 1;

    for(int i = 1; i <= n; i ++) 
        SegTree::Add(SegTree::root[i - 1], SegTree::root[i], 1, n, P[i].y, 1);

    int T; cin >> T;
    while(T --) {
        int x, y, t_x, t_y, k; cin >> t_x >> t_y >> k;
        x = t_x + t_y, y = t_x - t_y;
        int L = 0, R = 200000;
        while(L < R) {
            int mid = (L + R) >> 1;
            if(check(x, y, mid, k)) R = mid;
            else L = mid + 1;
        }
        cout << L << '\n';
    }

    return 0;
}

ABC234Ex Enumerate Pairs

浪费我感情的精巧暴力题。

把整个第一象限划分成一堆 $k\times k$ 的正方形，显然符合条件的点对要么在同一个正方形中，要么在两个有公共点的正方形中。

于是我们就可以对每个点，只检查以它所在正方形为中心的 $3\times 3$ 个正方形内部的点，接下来我们证明复杂度是有保证的。

将一个正方形再等分为 $4$ 个 $\frac{k}{2}\times \frac{k}{2}$ 的小正方形，每个区域内部的点对必然满足条件。设这个正方形内部共有 $a+b+c+d=w$ 个点，其中 $a,b,c,d$ 为四个小区域内部的点数，不妨设 $a\ge b\ge c\ge d$，那么这个正方形内部的，符合条件的点对数量就有 $(\genfrac{}{}{0ex}{}{a}{2})+(\genfrac{}{}{0ex}{}{b}{2})+(\genfrac{}{}{0ex}{}{c}{2})+(\genfrac{}{}{0ex}{}{d}{2})$。

注意到 $4a\ge a+b+c+d=w$，因此 $(\genfrac{}{}{0ex}{}{a}{2})=\frac{a(a-1)}{2}\ge \frac{w(w-4)}{32}$，因此每个正方形内部的点数是 $\mathcal{O}(\sqrt{A})$，其中 $A$ 是答案数量，于是暴力枚举的时间复杂度本质是是 $\mathcal{O}(n\sqrt{A})$，其中 $A$ 是答案数量。

ABC234Ex

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

struct Point {
    ll x, y;
    Point(ll _x = 0, ll _y = 0): x(_x), y(_y) {}
};

const int N = 2e5 + 10;
const ll B = 1e9 + 1;
int n; long long k; Point P[N];
map<ll, vector<int>> Map;
vector<pair<int, int>> ans;

inline bool check(Point a, Point b) {
    long long d = (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
    return d <= k * k;
}

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n >> k;
    for(int i = 1; i <= n; i ++) {
        cin >> P[i].x >> P[i].y;
        ll buc = (P[i].x / k) * B + (P[i].y / k);
        Map[buc].emplace_back(i);
    }
    for(int i = 1; i <= n; i ++) {
        ll buc = (P[i].x / k) * B + (P[i].y / k);
        static ll delta[] = {-B, -B - 1, -1, B - 1, B, B + 1, 1, -B + 1, 0};
        for(auto d : delta) {
            if(!Map.count(buc + d)) continue;
            vector<int> &vec = Map[buc + d];
            for(auto x : vec) 
                if(x < i && check(P[i], P[x])) ans.push_back({x, i});
        }
    }
    sort(ans.begin(), ans.end());
    cout << ans.size() << '\n';
    for(auto pr : ans)
        cout << pr.first << ' ' << pr.second << '\n';

    return 0;
}

ABC235Ex Painting Weighted Graph

把Kruskal重构树建出来，但是要稍微修改一下：将原来的二叉树改成多叉树，也就是不存在两个权值相同的点为父子关系，在连通性上的表现就是：将边权相同的边一起加入到图中。

例如若有三个点 $1,2,3$，两两之间有权值为 $1$ 的边，我们建出的Kruskal重构树并不形如 $1,2$ 的父亲是 $4$，$3,4$ 的父亲是 $5$，而是 $1,2,3$ 共有一个父亲 $4$。

对于一个最终可以到达的状态，不妨就在最小的操作次数内到达它：一次操作可以看作是在我们的Kruskal重构树上选择一个点并将它子树内的所有叶子染色，因此若两个染色关系为祖先后代关系，那么深度较大的染色无效。

然后就可以在树上做dp了，设 $d{p}_{u,i}$ 表示在 $u$ 的子树内操作了 $i$ 次，并且所有操作都有效，得到的最终状态数量，容易用背包转移。

根据树上背包的结论，这部分的时间复杂度为 $\mathcal{O}(nk)$，总时间复杂度 $\mathcal{O}(nk+(n+m)\log m)$。

ABC235Ex

#include <bits/stdc++.h>

using namespace std;

struct edge {
    int u, v, w;
    edge() {}
    edge(int _u, int _v, int _w): u(_u), v(_v), w(_w) {}
};
bool operator < (const edge &lhs, const edge &rhs) {return lhs.w < rhs.w; }

const int N = 1e5 + 10, K = 510, MOD = 998244353;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }
inline int ksm(long long a, int b) {
    long long r = 1;
    for(; b; b >>= 1, a = a * a % MOD)
        if(b & 1) r = r * a % MOD;
    return r;
}
int n, m, k; vector<edge> edges;

int p[N], id[N], tot;
int find(int x) {return x == p[x] ? x : p[x] = find(p[x]); }

vector<int> G[2 * N];
inline void add(int a, int b) {G[a].emplace_back(b); }

inline void calc(set<int> &merged) {
    for(auto u : merged)
        if(u == find(u)) add(tot + 1, id[u]), id[u] = ++tot;
    for(auto u : merged)
        if(u != find(u)) add(id[find(u)], id[u]);
    merged.clear();
}

int dp[2 * N][K], siz[2 * N];
inline void solve(int u, int v) {
    static int f[K];
    for(int i = 0; i <= min(siz[u] + siz[v], k); i ++)
        f[i] = 0;
    for(int i = 0; i <= min(siz[u], k); i ++)
        for(int j = 0; j <= min(siz[v], k - i); j ++)
            f[i + j] = Plus(f[i + j], 1ll * dp[u][i] * dp[v][j] % MOD);
    siz[u] += siz[v];
    for(int i = 0; i <= min(siz[u], k); i ++)
        dp[u][i] = f[i];
}
void dfs(int u) {
    dp[u][0] = 1, siz[u] = 1;
    for(auto v : G[u]) 
        dfs(v), solve(u, v);
    if(G[u].size() != 0 && G[u].size() <= k) {
        dp[u][G[u].size()] = Minus(dp[u][G[u].size()], 1);
    }
    dp[u][1] = Plus(dp[u][1], 1);
}

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n >> m >> k; edges.resize(m);
    for(int i = 0; i < m; i ++)
        cin >> edges[i].u >> edges[i].v >> edges[i].w;
    sort(edges.begin(), edges.end());

    tot = n;
    for(int i = 1; i <= n; i ++)
        p[i] = id[i] = i;
    set<int> merged;
    for(int i = 0; i < m; i ++) {
        if(i > 0 && edges[i].w != edges[i - 1].w) 
            calc(merged);
        int a = edges[i].u, b = edges[i].v;
        if(find(a) == find(b)) continue;
        merged.insert(find(a)), merged.insert(find(b));
        p[find(a)] = find(b);
    }
    calc(merged);

    dp[0][0] = 1; int root = 0;
    for(int i = 1; i <= n; i ++) 
        if(find(i) == i) 
            dfs(id[i]), solve(root, id[i]);
    int ans = 0;
    for(int i = 0; i <= k; i ++)
        ans = Plus(ans, dp[root][i]);
    cout << ans << '\n';

    return 0;
}

ABC236Ex Distinct Multiples

若 $A_i=A_j$ 则在 $i,j$ 两点之间连边，那么一个合法方案就是没有边的方案。

所有边将整张图划分为了一堆连通块，设边集 $U=\{(i,j):1\le i<j\le n\}$，$f_i$ 表示恰有 $i$ 条边的方案数，$g_i$ 表示钦定有 $i$ 条边的方案数，那么

$$\begin{array}{}& g_i=\sum _{j=i}^{\frac{n(n-1)}{2}}(\genfrac{}{}{0ex}{}{j}{i})f_j\end{array}$$

二项式反演立即得到

$$\begin{array}{}& f_i=\sum _{j=i}^{\frac{n(n-1)}{2}}(-1{)}^{j-i}(\genfrac{}{}{0ex}{}{j}{i})g_j\end{array}$$

答案即 $f_0$，有

$$\begin{array}{}& f_0=\sum _{i=0}^{\frac{n(n-1)}{2}}(-1{)}^i{g}_i\end{array}$$

只需要算出 $g$ 就好了，考虑枚举最终构成的连通块形状 $P$（$P$ 是一个集族，每个元素是一个点集，并且所有元素的并集为所有点）。对于点集 $S$，记 $\mathrm{lcm}(S)$ 表示这些 $i\in S$ 的 $A_i$ 的 $\mathrm{lcm}$，那么答案可以写作

$$\begin{array}{}& \sum _P\left(\prod _{S\in P}\lfloor \frac{M}{\mathrm{lcm}(S)}\rfloor \right)\sum _{E\subseteq U}[E\text{构成的连通块恰为}P](-1{)}^{|E|}\end{array}$$

对于后面那个 $\sum _{E\subseteq U}[E\text{构成的连通块恰为}P](-1{)}^{|E|}$，只和 $P$ 中每个点集的点数有关，设 $k$ 个点之间连边构成一个连通块的 $(-1{)}^{\text{边数个数}}$ 之和为 $h_k$，那么它就等于

$$\begin{array}{}& \prod _{S\in P}{h}_{|S|}\end{array}$$

而 $h$ 是可以算的：没有连通限制时，$(-1{)}^{\text{边数个数}}$ 之和为 $[k=1]$，也就是 $[x^k]\exp h=[k=1]$，取 $\ln$ 得到 $h=\ln x$，也就是 $h_k=(-1{)}^{k-1}(k-1)!$。

于是答案就是

$$\begin{array}{}& \sum _P\left(\prod _{S\in P}\lfloor \frac{M}{\mathrm{lcm}(S)}\rfloor \right)(\prod _{S\in P}(-1{)}^{|S|-1}(|S|-1)!)\end{array}$$

子集卷积 $\exp$ 优化可以做到 $\mathcal{O}((n^2+\log m)2^n)$，暴力枚举子集做转移是 $\mathcal{O}(3^n+2^n\log m)$ 的。

$\mathcal{O}(3^n+2^n\log m)$

#include <bits/stdc++.h>

using namespace std;

const int N = 16, MOD = 998244353;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }
int n; long long m, D[N], w[N + 10];

inline long long lcm(long long a, long long b) {
    if(a > m || b > m) return m + 1;
    __int128 ans = (__int128)a / __gcd(a, b) * b;
    return ans > m ? m + 1 : ans;
}
inline int pcnt(int x) {return __builtin_popcount(x); }
long long L[1 << N], f[1 << N], g[1 << N];

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n >> m;
    for(int i = 0; i < n; i ++)
        cin >> D[i];
    L[0] = 1;
    for(int i = 1; i < (1 << n); i ++)
        L[i] = lcm(L[i ^ (i & -i)], D[__lg(i & -i)]);
    for(int i = 0; i < (1 << n); i ++)
        g[i] = (m / L[i]) % MOD;

    w[1] = 1;
    for(int i = 2; i <= n; i ++)
        w[i] = 1ll * w[i - 1] * (i - 1) % MOD;
    for(int i = 0; i <= n + 1; i += 2)
        w[i] = Minus(0, w[i]);
    f[0] = 1;
    for(int i = 1; i < (1 << n); i ++) {
        int u = __lg(i & -i);
        for(int j = i; j; j = (j - 1) & i) {
            if(!(j >> u & 1)) continue;
            f[i] = Plus(f[i], 1ll * f[i ^ j] * g[j] % MOD * w[pcnt(j)] % MOD);
        }
    }
    cout << f[(1 << n) - 1] << '\n';

    return 0;
}

$\mathcal{O}((n^2+\log m)2^n)$

#include <bits/stdc++.h>

using namespace std;

const int N = 16, MOD = 998244353;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }
int n; long long m, D[N], w[N + 10];
int inv[N + 1], fac[N + 1], ifac[N + 1];

inline long long lcm(long long a, long long b) {
    if(a > m || b > m) return m + 1;
    __int128 ans = (__int128)a / __gcd(a, b) * b;
    return ans > m ? m + 1 : ans;
}
inline int pcnt(int x) {return __builtin_popcount(x); }
long long L[1 << N];
int f[N + 1][1 << N], g[N + 1][1 << N];

inline void FWT(int A[], int n, int type) {
    for(int h = 2; h <= n; h <<= 1)
        for(int i = 0; i < n; i += h)
            for(int j = i; j < i + (h >> 1); j ++) {
                if(type == 1) A[j + (h >> 1)] = Plus(A[j + (h >> 1)], A[j]);
                else A[j + (h >> 1)] = Minus(A[j + (h >> 1)], A[j]);
            }
}
inline void exp(int f[], int g[], int n) {
    for(int i = 0; i <= n; i ++) g[i] = 0;
    g[0] = 1;
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= i; j ++)
            g[i] = Plus(g[i], 1ll * j * f[j] % MOD * g[i - j] % MOD);
        g[i] = 1ll * g[i] * inv[i] % MOD;
    }
}

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n >> m;
    inv[1] = fac[0] = fac[1] = ifac[0] = ifac[1] = 1;
    for(int i = 2; i <= n; i ++) {
        inv[i] = Minus(0, 1ll * (MOD / i) * inv[MOD % i] % MOD);
        fac[i] = 1ll * fac[i - 1] * i % MOD;
        ifac[i] = 1ll * ifac[i - 1] * inv[i] % MOD;
    }
    
    for(int i = 0; i < n; i ++)
        cin >> D[i];
    L[0] = 1;
    for(int i = 1; i < (1 << n); i ++)
        L[i] = lcm(L[i ^ (i & -i)], D[__lg(i & -i)]);
    for(int i = 0; i < (1 << n); i ++)
        f[__builtin_popcount(i)][i] = (m / L[i]) % MOD;

    w[1] = 1;
    for(int i = 2; i <= n; i ++)
        w[i] = 1ll * w[i - 1] * (i - 1) % MOD;
    for(int i = 0; i <= n + 1; i += 2)
        w[i] = Minus(0, w[i]);
    for(int i = 0; i < (1 << n); i ++)
        f[__builtin_popcount(i)][i] = 1ll * f[__builtin_popcount(i)][i] * w[pcnt(i)] % MOD;
    for(int i = 0; i <= n; i ++) 
        FWT(f[i], 1 << n, 1);
    
    for(int mask = 0; mask < (1 << n); mask ++) {
        static int F[N + 1], G[N + 1];
        for(int i = 0; i <= n; i ++)
            F[i] = f[i][mask];
        exp(F, G, n);
        for(int i = 0; i <= n; i ++)
            g[i][mask] = G[i];
    }
    FWT(g[n], 1 << n, -1);
    cout << g[n][(1 << n) - 1] << '\n';

    return 0;
}

ABC237Ex Hakata

根据经典结论：本质不同的回文子串个数只有 $\mathcal{O}(|S|)$ 个，我们可以将这些串 $\mathcal{O}(|S{|}^3)$ 全部找出来，若串 $x$ 是串 $y$ 的子串，那么就连有向边 $(x,y)$，答案即为这个图的最长反链。

根据Dilworth定理，所求即为最小链覆盖，建二分图，若有原边 $(x,y)$，那么连 $x$ 的左部点到 $y$ 的右部点，跑二分图最大匹配，答案就是左部点个数减去最大匹配。

时间复杂度 $\mathcal{O}(|S{|}^3)$。

ABC237Ex

#include <bits/stdc++.h>

using namespace std;


string S;
set<string> Set;
inline bool check(string s) {
    for(int i = 0; i < s.size(); i ++)
        if(s[i] != s[(int)s.size() - 1 - i]) return false;
    return true;
}
inline bool cover(string &x, string &y) {
    if(x.size() > y.size()) return false;
    for(int i = 0; i + x.size() <= y.size(); i ++) {
        bool flag = true;
        for(int j = 0; j < x.size(); j ++)
            if(x[j] != y[i + j]) {flag = false; break; }
        if(flag) return true;
    }
    return false;
}
vector<string> vec;

struct Dinic {
    static const int N = 410, INF = 0x3f3f3f3f;
    struct edge {
        int from, to, cap, flow;
        edge(int u, int v, int c, int f): from(u), to(v), cap(c), flow(f) {}
    };
    vector<edge> edges; vector<int> G[N];
    inline void AddEdge(int u, int v, int c) {
        static int M;
        edges.emplace_back(edge(u, v, c, 0)), edges.emplace_back(edge(v, u, 0, 0));
        M = edges.size(); G[u].emplace_back(M - 2), G[v].emplace_back(M - 1);
    }
    int s, t, dist[N], cur[N];
    inline bool BFS() {
        memset(dist, 0, sizeof dist);
        dist[s] = 1; queue<int> Q; Q.push(s);
        while(!Q.empty()) {
            int u = Q.front(); Q.pop();
            for(auto i : G[u]) {
                edge &e = edges[i];
                if(dist[e.to] || e.flow == e.cap) continue;
                dist[e.to] = dist[u] + 1; Q.push(e.to);
            }
        }
        return dist[t];
    }
    int dfs(int u, int F) {
        if(u == t || F <= 0) return F;
        int flow = 0;
        for(int &i = cur[u]; i < G[u].size(); i ++) {
            auto &e = edges[G[u][i]];
            if(dist[e.to] == dist[e.from] + 1 && e.flow < e.cap) {
                int f = dfs(e.to, min(F, e.cap - e.flow));
                flow += f, F -= f, e.flow += f, edges[G[u][i] ^ 1].flow -= f;
                if(!F) break;
            }
        }
        return flow;
    }
    int MaxFlow(int s, int t) {
        this->s = s, this->t = t;
        int res = 0;
        while(BFS()) {
            memset(cur, 0, sizeof cur);
            res += dfs(s, INF);
        }
        return res;
    }
} solver;

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> S;
    for(int i = 0; i < S.size(); i ++) {
        for(int len = 1; len <= i + 1; len ++)
            if(check(S.substr(i - len + 1, len))) 
                Set.insert(S.substr(i - len + 1, len));
    }
    vec.resize(Set.size()); int i = 0;
    for(auto it = Set.begin(); it != Set.end(); it = Set.erase(it)) 
        vec[i ++] = *it;

    int n = vec.size(); int s = 2 * n, t = s + 1;
    for(int i = 0; i < n; i ++)
        solver.AddEdge(s, i, 1), solver.AddEdge(i + n, t, 1);
    for(int i = 0; i < n; i ++) {
        for(int j = 0; j < n; j ++) {
            if(j == i || !cover(vec[i], vec[j])) continue;
            solver.AddEdge(i, j + n, 1);
        }
    }
    cout << n - solver.MaxFlow(s, t) << '\n';

    return 0;
}

[ABC242Ex] Random Painting

只需要求出所有方案的答案和再除以总方案数也就是 $n!$ 就可以知道期望了。

考虑从最终状态回到初始状态的过程：一开始只有最后留下的一个人，每次可以新加进来一个人。

然后考虑区间dp，设 $f_{l,r}$ 表示只考虑第 $l$ 个人到第 $r$ 个人，其中第 $l$ 个人和第 $r$ 个人已经被加进来的答案，设 $g_{l,r}$ 表示相应的方案数。

转移形如

$$\begin{array}{rl}{g}_{l,r}& \leftarrow (\genfrac{}{}{0ex}{}{r-l-2}{k-l-1})g_{l,k}\times g_{k,r}\times c_1\\ f_{l,r}& \leftarrow (\genfrac{}{}{0ex}{}{r-l-2}{k-l-1})(g_{l,k}\times g_{k,r}\times c_2+f_{l,k}\times g_{k,r}\times c_1+g_{l,k}\times f_{k,r}\times c_1)\end{array}$$

其中

$$\begin{array}{rl}{c}_1& =[S_l=\text{R}]+[S_r=\text{L}]\\ c_2& =[S_l=\text{R}](k-l)+[S_r=\text{L}](r-k)\end{array}$$

上面组合数的意义是随便排列两部分之间的顺序，$c_1$ 表示 $k$ 的选择方案（将 $k$ 删去的人的方案数），$c_2$ 表示 $k$ 的选择方案的距离和。$k$ 对 $f_{l,r}$ 的贡献就是方案数乘上距离和，即 $g_{l,k}\times g_{k,r}\times c_2$，然后左右两部分的贡献再分别算即可，总时间复杂度 $\mathcal{O}(n^3)$，注意我们是在环上做的区间dp即可。

ABC242Ex

#include <bits/stdc++.h>

using namespace std;

const int N = 310, MOD = 998244353;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }
inline int ksm(long long a, int b) {
    long long r = 1;
    for(; b; b >>= 1, a = a * a % MOD)
        if(b & 1) r = r * a % MOD;
    return r;
}
int fac[N], ifac[N];
inline int C(int a, int b) {return a >= b ? 1ll * fac[a] * ifac[b] % MOD * ifac[a - b]  % MOD : 0; }
int n; char S[N];
int f[N][N], g[N][N];

int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    
    cin >> n >> (S + 1);
    fac[0] = 1; for(int i = 1; i <= n; i ++) fac[i] = 1ll * fac[i - 1] * i % MOD;
    ifac[n] = ksm(fac[n], MOD - 2); for(int i = n; i >= 1; i --) ifac[i - 1] = 1ll * ifac[i] * i % MOD;
    
    for(int i = 1; i < n; i ++) 
        f[i][i + 1] = 0, g[i][i + 1] = 1;
    f[n][1] = 0, g[n][1] = 1;
    
    for(int len = 3; len <= n + 1; len ++) for(int l = 1; l <= n; l ++) {
        int r = l + len - 1; 
        for(int k = l + 1; k < r; k ++) {
            int L = (l > n ? l - n : l), R = (r > n ? r - n : r), K = (k > n ? k - n : k);
            int c1 = (S[L] == 'R') + (S[R] == 'L');
            int c2 = (S[L] == 'R' ? k - l : 0) + (S[R] == 'L' ? r - k : 0);
            g[L][R] = Plus(g[L][R], 1ll * g[L][K] * g[K][R] % MOD * c1 % MOD * C(r - l - 2, k - l - 1) % MOD); 
            int add = 1ll * g[L][K] * g[K][R] % MOD * c2 % MOD;
            add = Plus(add, 1ll * g[L][K] * c1 % MOD * f[K][R] % MOD);
            add = Plus(add, 1ll * g[K][R] * c1 % MOD * f[L][K] % MOD);
            f[L][R] = Plus(f[L][R], 1ll * add * C(r - l - 2, k - l - 1) % MOD);
        }
    }
    
    int ans = 0;
    for(int i = 1; i <= n; i ++)
        ans = Plus(ans, f[i][i]);
    ans = 1ll * ans * ifac[n] % MOD;
    cout << ans << '\n';
    
    return 0;
}

[ABC239Ex] Dice Product 2

设 $f(x)$ 表示目前的值 $\ge x$ 的期望次数，初始值 $f(1)=0$，所求即为 $f(m+1)$。

枚举最后一次扔到的点数，有转移

$$f(x)=1+\sum _{i=1}^n\frac{1}{n}f\left(\lceil \frac{x}{i}\rceil \right)$$

当右边的求和中 $i=1$ 时我们会用到 $f(x)$，所以将它移到左边然后变形得到

$$\frac{n-1}{n}f(x)=1+\frac{\sum _{i=2}^{n}f\left(\lceil \frac{x}{i}\rceil \right)}{n}$$

也就是

$$f(x)=\frac{n+\sum _{i=2}^{n}f\left(\lceil \frac{x}{i}\rceil \right)}{n-1}$$

此时就只需要知道 $f(y),y<x$ 就可以得到 $f(x)$ 了，可以递推求得所有 $f(x)$。

复杂度显然是不对的，假如要求出所有 $f(1..m+1)$，复杂度是 $\mathcal{O}(n\sqrt{n})$ 的（默认 $n,m$ 同阶）。但是我们只需要知道 $f(m+1)$ 即可，可以记忆化搜索，只计算需要用到的 $f$ 值，下面我们证明时间复杂度是 $\mathcal{O}(n^{3/4})$，用哈希表记忆化，可以通过。

时间复杂度部分：

假如我们要计算 $f(m)$，设 $L=\lfloor \sqrt{m}\rfloor$，将所有待计算的 $f(x)$ 分为两份：

• $x\in [1,L]$，这部分的时间复杂度是 $L\times \mathcal{O}(\sqrt{L})=\mathcal{O}(m^{3/4})$。
• $x=\lfloor m/1\rfloor ,\lfloor m/2\rfloor ,\lfloor m/3\rfloor ,\cdots ,\lfloor m/L\rfloor$，用积分估计这部分的和，是 $\mathcal{O}({\int }_1^L\sqrt{m/x})=\mathcal{O}(m^{3/4})$的。

因此总时间复杂度为 $\mathcal{O}(m^{3/4})$。

ABC239Ex

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/hash_policy.hpp>

using namespace std;
using namespace __gnu_pbds;

const int MOD = 1e9 + 7;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }
inline int ksm(long long a, int b) {
    long long r = 1;
    for(; b; b >>= 1, a = a * a % MOD)
        if(b & 1) r = r * a % MOD;
    return r;
}
int n, T;

gp_hash_table<int, int> F;
inline int f(int x) {
    if(F.find(x) != F.end()) return F[x];
    int ans = n, t = x - 1;
    for(int l = 2, r; l <= n; l = r + 1) {
        r = min(n, (t < l ? n : t / (t / l)));
        ans = Plus(ans, 1ll * f(t / l + 1) * (r - l + 1) % MOD);
    }
    return F[x] = 1ll * ans * T % MOD;
}

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    int m; cin >> n >> m;
    T = ksm(n - 1, MOD - 2);
    F[1] = 0, cout << f(m + 1) << '\n';

    return 0;
}

[ABC240Ex] Sequence of Substrings

一个暴力的想法是将所有子串插入到Trie中，然后设 $f_i$ 表示前 $i$ 个字符的答案，在Trie上按照字典序走，每次走的时候做一次转移（枚举所有该点的串，然后用 $f_{pos-len}+1$ 转移到 $f_{pos}$）。

假如用树状数组做单点更新最大值、查询前缀最大值，可以做到 $\mathcal{O}(n^2\log n)$。

注意到最终答案里相邻两个串要么长度不变或变小，要么长度加一（若长度加了二，可以删去最后一个字符，方案依然合法），于是只有长度不超过 $\sqrt{2n}$ 的子串是有用的，于是只需要将这些串插入到Trie中做，时间复杂度就变为 $\mathcal{O}(n\sqrt{n}\log n)$ 了，可以通过。

ABC240Ex

#include <bits/stdc++.h>

using namespace std;

const int N = 2.5e4 + 10, M = 250;
int n, m; char S[N];

struct Fenwick {
    int C[N];
    Fenwick() {memset(C, 0, sizeof C); }
    inline void upd(int p, int x) {for(; p <= n; p += p & -p) C[p] = max(C[p], x); }
    inline int ask(int p) {int r = 0; for(; p; p -= p & -p) r = max(r, C[p]); return r; }
} BIT;

namespace Trie {
    int ch[N * M][2], tot = 0;
    vector<int> pos[N * M];
    inline void insert(int p) {
        int u = 0;
        for(int i = p; i <= min(n, p + m); i ++) {
            if(!ch[u][S[i] - '0']) ch[u][S[i] - '0'] = ++tot;
            u = ch[u][S[i] - '0'];
            pos[u].emplace_back(i);
        }
    }
    vector<pair<int, int>> vec;
    void dfs(int u, int dep) {
        vec.clear();
        for(auto x : pos[u]) 
            vec.push_back({x, BIT.ask(x - dep) + 1});
        for(auto pr : vec)
            BIT.upd(pr.first, pr.second);
        if(ch[u][0]) dfs(ch[u][0], dep + 1);
        if(ch[u][1]) dfs(ch[u][1], dep + 1);
    }
}

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n >> (S + 1);
    m = (int)sqrt(2 * n);
    for(int i = 1; i <= n; i ++)
        Trie::insert(i);
    Trie::dfs(0, 0);
    cout << BIT.ask(n) << '\n';

    return 0;
}

[ABC241Ex] Card Deck Score

答案即为

$$[x^m]\prod _{i=1}^n\frac{1-(a_{i}x{)}^{b_i+1}}{1-a_{i}x}$$

但是 $m$ 是 ${10}^{18}$ 级别的，直接求逆是不现实的，因此我们尝试将需要求逆的部分做一下变换，具体地，原式等于

$$[x^m](\prod _{i=1}^n(1-(a_{i}x{)}^{b_i+1}))\left(\prod _{i=1}^n\frac{1}{1-a_{i}x}\right)$$

只关注 $\prod _{i=1}^n\frac{1}{1-a_{i}x}$ 的部分，用部分分式定理，它一定可以写成

$$\prod _{i=1}^n\frac{1}{1-a_{i}x}=\sum _{i=1}^n\frac{T_i}{1-a_{i}x}$$

两边同乘 $\prod _{i=1}^n(1-a_{i}x)$，得到

$$1=\sum _{i=1}^n{T}_i\prod _{j\ne i}(1-a_{j}x)$$

分别代入 $x=\frac{1}{a_i}$，得到

$$1=T_i\prod _{j\ne i}(1-\frac{a_j}{a_i})$$

移项就立即得到

$$T_i=\frac{1}{\prod _{j\ne i}(1-\frac{a_j}{a_i})}$$

右边是可以 $\mathcal{O}(n)$ 求得的，于是我们可以 $\mathcal{O}(n^2)$ 求得所有 $T_i$。

知道了所有 $T_i$，我们就可以知道

$$[x^c]\prod _{i=1}^n\frac{1}{1-a_{i}x}=\sum _{i=1}^n[x^c]\frac{T_i}{1-a_{i}x}=\sum _{i=1}^n{T}_i{a}_i^c$$

后面就是白给内容了，$\mathcal{O}(n{2}^n)$ 暴力求出来 $\prod _{i=1}^n(1-(a_{i}x{)}^{b_i+1})$，对其中的每一项 $c{x}^k$，求出 $t=[x^{m-k}]\prod _{i=1}^n\frac{1}{1-a_{i}x}$，然后将 $c\times t$ 累加到答案中即可，总时间复杂度 $\mathcal{O}(n{2}^n+n^2)$。

ABC241Ex

#include <bits/stdc++.h>

using namespace std;

const int N = 20, MOD = 998244353;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }
inline int ksm(long long a, long long b) {
    long long r = 1;
    for(; b; b >>= 1, a = a * a % MOD)
        if(b & 1) r = r * a % MOD;
    return r;
}

int n, A[N], iA[N], T[N]; long long m, B[N];
inline void merge(map<long long, int> &P, map<long long, int> &Q) {
    map<long long, int> ans;
    for(auto x : P) for(auto y : Q) {
        if(x.first + y.first > m) continue;
        ans[x.first + y.first] = Plus(ans[x.first + y.first], 1ll * x.second * y.second % MOD);
    }
    P.swap(ans);
}
map<long long, int> f;

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n >> m;
    for(int i = 1; i <= n; i ++)
        cin >> A[i] >> B[i], iA[i] = ksm(A[i], MOD - 2);
    
    for(int i = 1; i <= n; i ++) {
        T[i] = 1;
        for(int j = 1; j <= n; j ++) {
            if(j == i) continue;
            T[i] = 1ll * T[i] * Minus(1, 1ll * A[j] * iA[i] % MOD) % MOD;
        }
        T[i] = ksm(T[i], MOD - 2);
    }

    f[0] = 1, f[B[1] + 1] = Minus(0, ksm(A[1], B[1] + 1));
    for(int i = 2; i <= n; i ++) {
        map<long long, int> tmp;
        tmp[0] = 1, tmp[B[i] + 1] = Minus(0, ksm(A[i], B[i] + 1));
        merge(f, tmp);
    }

    int ans = 0;
    for(auto pr : f) {
        long long r = m - pr.first, mul = 0;
        if(r < 0) continue;
        for(int i = 1; i <= n; i ++)
            mul = Plus(mul, 1ll * T[i] * ksm(A[i], r) % MOD);
        ans = Plus(ans, 1ll * pr.second * mul % MOD);
    }
    cout << ans << '\n';

    return 0;
}

[ABC242Ex] Random Painting

设 $A_i$ 表示第 $i$ 个方块被染色的时间，所求即为 $\mathbb{E}(max{A}_i)$。

根据min-max容斥，设全集 $U=1,2,\cdots ,n$，所求即为

$$\mathbb{E}(\underset{x\in U}{max}{A}_x)=\sum _{S\subseteq U}(-1{)}^{|S|+1}\mathbb{E}(\underset{x\in S}{min}{A}_x)$$

设 $c_S$ 表示有多少个小球对应的区间覆盖到了集合 $S$ 中的某个元素，那么每次染色染到 $S$ 中任一元素的概率即为 $\frac{c_S}{m}$，于是 $\mathbb{E}(\underset{x\in S}{min}{A}_x)=\frac{m}{c_S}$。

所求即为

$$\sum _{S\subseteq U}(-1{)}^{|S|+1}\frac{m}{c_S}$$

dp，设 $f_{i,j,0/1}$ 表示只考虑前 $i$ 个小方块，钦定 $i\in S$ 时 $c_S=j$ 并且 $(|S|+1)mod2=0/1$ 的方案数，枚举倒数第二个在 $S$ 中的小方块 $k$，有转移

$$f_{i,j,0/1}=\sum _{k=0}^{i-1}{f}_{k,j-g_{k+1},1/0}$$

其中 $g_{k+1}$ 表示 $L\in [k+1,i],R\in [i,n]$ 的小球数量，容易求得，总时间复杂度 $\mathcal{O}(n^{2}m)$。

ABC242Ex

#include <bits/stdc++.h>

using namespace std;

const int N = 410, MOD = 998244353;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }
inline int ksm(long long a, int b) {
    long long r = 1;
    for(; b; b >>= 1, a = a * a % MOD)
        if(b & 1) r = r * a % MOD;
    return r;
}

int n, m, L[N], R[N], siz_L[N];
vector<int> all_R[N];
int f[N][N][2], g[N];

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n >> m;
    for(int i = 1; i <= m; i ++) {
        cin >> L[i] >> R[i];
        siz_L[L[i]] ++, all_R[R[i]].emplace_back(L[i]);
    }

    f[0][0][1] = 1;
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= i; j ++)
            g[j] += siz_L[i];
        for(auto l : all_R[i - 1])
            for(int j = 1; j <= l; j ++)
                g[j] --;
        for(int j = 0; j <= m; j ++) {
            for(int k = 0; k < i; k ++) 
                if(j - g[k + 1] >= 0) {
                    f[i][j][0] = Plus(f[i][j][0], f[k][j - g[k + 1]][1]),
                    f[i][j][1] = Plus(f[i][j][1], f[k][j - g[k + 1]][0]);
                }
        }
    }

    static int c[N];
    memset(c, 0, sizeof c);
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            c[j] = Plus(c[j], Minus(f[i][j][0], f[i][j][1]));
    int ans = 0;
    for(int i = 1; i <= m; i ++)
        ans = Plus(ans, 1ll * c[i] * ksm(i, MOD - 2) % MOD);
    ans = 1ll * ans * m % MOD;
    cout << ans << '\n';
    
    return 0;
}