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\)，那么这个正方形内部的，符合条件的点对数量就有 \(\binom{a}{2}+\binom{b}{2}+\binom{c}{2}+\binom{d}{2}\)。

注意到 \(4a \ge a+b+c+d=w\)，因此 \(\binom{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了，设 \(dp_{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\) 条边的方案数，那么

\[g_i=\sum_{j=i}^{\frac{n(n-1)}{2}}\binom{j}{i}f_j \nonumber \]

二项式反演立即得到

\[f_i=\sum_{j=i}^{\frac{n(n-1)}{2}}(-1)^{j-i}\binom{j}{i}g_j \nonumber \]

答案即 \(f_0\)，有

\[f_0=\sum_{i=0}^{\frac{n(n-1)}{2}}(-1)^ig_i \nonumber \]

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

\[\sum_P \left( \prod_{S \in P} \left\lfloor \frac{M}{\operatorname{lcm}(S)} \right\rfloor \right)\sum_{E \subseteq U}[E\text{构成的连通块恰为}P](-1)^{|E|} \nonumber \]

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

\[\prod_{S \in P} h_{|S|} \nonumber \]

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

于是答案就是

\[\sum_{P}\left( \prod_{S \in P}\left\lfloor \frac{M}{\operatorname{lcm}(S)} \right\rfloor \right)\left( \prod_{S \in P}(-1)^{|S|-1}(|S|-1)! \right) \nonumber \]

子集卷积 \(\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{aligned} g_{l,r}&\leftarrow\binom{r-l-2}{k-l-1}g_{l,k} \times g_{k,r} \times c_1\newline f_{l,r}&\leftarrow\binom{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{aligned} \]

其中

\[\begin{aligned} c_1&=[S_l=\text{R}]+[S_r=\text{L}]\newline c_2&=[S_l=\text{R}](k-l)+[S_r=\text{L}](r-k) \end{aligned} \]

上面组合数的意义是随便排列两部分之间的顺序，\(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( \left\lceil \frac{x}{i} \right\rceil \right) \]

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

\[\frac{n-1}{n}f(x)=1+\frac{\sum_{i=2}^{n}f\left( \left\lceil \frac{x}{i} \right\rceil \right)}{n} \]

也就是

\[f(x)=\frac{n+\sum_{i=2}^{n}f\left( \left\lceil \frac{x}{i} \right\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_ix)^{b_i+1}}{1-a_ix} \]

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

\[[x^m]\left( \prod_{i=1}^{n}(1-(a_ix)^{b_i+1}) \right)\left( \prod_{i=1}^{n}\frac{1}{1-a_ix} \right) \]

只关注 \(\prod_{i=1}^{n}\frac{1}{1-a_ix}\) 的部分，用部分分式定理，它一定可以写成

\[\prod_{i=1}^{n}\frac{1}{1-a_ix}=\sum_{i=1}^{n}\frac{T_i}{1-a_ix} \]

两边同乘 \(\prod_{i=1}^{n}(1-a_ix)\)，得到

\[1=\sum_{i=1}^{n}T_i\prod_{j \ne i}(1-a_jx) \]

分别代入 \(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_ix}=\sum_{i=1}^{n}[x^c]\frac{T_i}{1-a_ix}=\sum_{i=1}^{n}T_ia_i^{c} \]

后面就是白给内容了，\(\mathcal{O}(n2^n)\) 暴力求出来 \(\prod_{i=1}^{n}(1-(a_ix)^{b_i+1})\)，对其中的每一项 \(cx^k\)，求出 \(t=[x^{m-k}]\prod_{i=1}^{n}\frac{1}{1-a_ix}\)，然后将 \(c \times t\) 累加到答案中即可，总时间复杂度 \(\mathcal{O}(n2^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}(\max_{x \in U}A_x)=\sum_{S \subseteq U}(-1)^{|S|+1}\mathbb{E}(\min_{x \in S}A_x) \]

设 \(c_S\) 表示有多少个小球对应的区间覆盖到了集合 \(S\) 中的某个元素，那么每次染色染到 \(S\) 中任一元素的概率即为 \(\frac{c_S}{m}\)，于是 \(\mathbb{E}(\min_{x \in S}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) \bmod 2 =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^2m)\)。

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