ABC 269Ex Antichain

题目描述

https://atcoder.jp/contests/abc269/tasks/abc269_h

简要题意：给定一棵大小为 $n$ 的有根树，求对于所有 $k\in[1,n]$，有多少大小为 $k$ 的集合，满足集合内不存在任意两点使得一个点是另一个点的祖先

$n\le 2\times 10^5$

Solution

我们令 $f_u(x)$ 表示以 $u$ 为根的子树的生成函数，容易得到 $f_u(x)=1+x+\prod_{v}f_v(x)$，但是我们如果直接这样乘，复杂度显然是 $O(n^2\log n)$，我们参考 $dsu$ 的优化方法，首先将整棵树轻重链剖分

我们令 $g_u(x)$ 表示 $\prod_{v\neq son_u}f_v(x)$，其中 $son_u$ 表示 $u$ 的重儿子，然后对于每条重链我们在链首单独求解，注意多个多项式乘的时候必须分治来乘，这样的时间复杂度为 $O(n\log^3 n)$，但实际运行时可以接收的

对于重链，我们不妨令其长度为 $k$，从链首到链尾的节点构成的序列为 $a_i$，那么我们有 $f_{a_1}(x)=\prod_{i=1}^kg_{a_i}(x)+\sum_{i=1}^kx\prod_{j=1}^{i-1}g_{a_j}(x)$，前面那个 $\prod$ 表示不选重链上的点，后面的 $\sum$ 枚举的选择重链上的哪个点，重链的计算也可以分治来求

#include <iostream>
#include <vector>
#include <algorithm>
#define maxn 200010
#define ll long long
using namespace std;

const int p = 998244353;
inline int add(int x, int y) { return (x += y) >= p ? x - p : x; }
inline int mul(int x, int y) { return 1ll * x * y % p; }
inline int add(initializer_list<int> lst) { int s = 0; for (auto t : lst) s = add(s, t); return s; }
inline int mul(initializer_list<int> lst) { int s = 1; for (auto t : lst) s = mul(s, t); return s; }
int pow_mod(int x, int n) {
    int s = 1;
    for (; n; n >>= 1, x = mul(x, x))
        if (n & 1) s = mul(s, x);
    return s; 
}

#define Poly vector<int>
#define len(A) ((int) A.size())
namespace Pol {
    inline int add(int a, int b) { return (a += b) >= p ? a -= p : a; }
    inline int mul(int a, int b) { return 1ll * a * b % p; } 
    Poly operator - (const int &v, const Poly &a) {
        Poly res(a); 
        for (int i = 0; i < len(res); ++i) res[i] = p - res[i]; 
        res[0] = add(res[0], v); return res;
    }
    Poly operator - (const Poly &a, const int &v) {
        Poly res(a); res[0] = add(res[0], p - v); return res;
    }
    Poly operator * (const Poly &a, const int &v) {
        Poly res(a);
        for (int i = 0; i < len(res) ; ++i) res[i] = mul(res[i], v); 
        return res;
    }
 
    const int N = 4200000;
    const int G = 3;
    
    int P[N], inv[N], fac[N];
    void init_P(int n) {
        int l = 0; while ((1 << l) < n) ++l;
        for (int i = 0; i < n; ++i) P[i] = (P[i >> 1] >> 1) | ((i & 1) << l - 1);
    }
    void init_C() {
        if (fac[0]) return ;
        fac[0] = 1; for (int i = 1; i < N; ++i) fac[i] = mul(fac[i - 1], i);
        inv[N - 1] = pow_mod(fac[N - 1], p - 2); for (int i = N - 2; ~i; --i) inv[i] = mul(inv[i + 1], i + 1);
    }
    vector<int> init_W(int n) {
        vector<int> w(n); w[1] = 1;
        for (int i = 2; i < n; i <<= 1) {
            auto w0 = w.begin() + i / 2, w1 = w.begin() + i;
            int wn = pow_mod(G, (p - 1) / (i << 1));
            for (int j = 0; j < i; j += 2)
                w1[j] = w0[j >> 1], w1[j + 1] = mul(w1[j], wn);
        }
        return w; 
    } auto w = init_W(1 << 21);
    void DIT(Poly &a) {
        int n = len(a);
        for (int k = n >> 1; k; k >>= 1)
            for (int i = 0; i < n; i += k << 1)
                for (int j = 0; j < k; ++j) {
                    int x = a[i + j], y = a[i + j + k];
                    a[i + j + k] = mul(add(x, p - y), w[k + j]), a[i + j] = add(x, y);
                }
    }
    void DIF(Poly &a) {
        int n = len(a); 
        for (int k = 1; k < n; k <<= 1)
            for (int i = 0; i < n; i += k << 1)
                for (int j = 0; j < k; ++j) {
                    int x = a[i + j], y = mul(a[i + j + k], w[k + j]);
                    a[i + j + k] = add(x, p - y), a[i + j] = add(x, y);
                }
        int inv = pow_mod(n, p - 2);
        for (int i = 0; i < n; ++i) a[i] = mul(a[i], inv);
        reverse(a.begin() + 1, a.end());
    }
    Poly operator * (const Poly &A, const Poly &B) {
        int n = 1, n1 = len(A), n2 = len(B); while (n < n1 + n2 - 1) n <<= 1; init_P(n);
        Poly a(n), b(n);
        for (int i = 0; i < n1; ++i) a[i] = add(A[i], p);
        for (int i = 0; i < n2; ++i) b[i] = add(B[i], p);
        DIT(a); DIT(b);
        for (int i = 0; i < n; ++i) a[i] = mul(a[i], b[i]);
        DIF(a); a.resize(n1 + n2 - 1); return a; 
    }
    Poly MMul(const Poly &A, const Poly &B) { // 差卷积, 默认 A 和 B 的长度相同
        int n = 1, L = len(A); while (n < 2 * L - 1) n <<= 1; init_P(n);
        Poly a(n), b(n);
        for (int i = 0; i < L; ++i) a[i] = add(A[i], p);
        for (int i = 0; i < L; ++i) b[i] = add(B[i], p);
        reverse(b.begin(), b.begin() + L);
        DIT(a); DIT(b);
        for (int i = 0; i < n; ++i) a[i] = mul(a[i], b[i]);
        DIF(a); a.resize(L); reverse(a.begin(), a.end()); return a; 
    }
    Poly Der(const Poly &a) {
        Poly res(a);
        for (int i = 0; i < len(a) - 1; ++i) res[i] = mul(i + 1, res[i + 1]);
        res[len(a) - 1] = 0; return res;
    }
    Poly Int(const Poly &a) {
        static int inv[N];
        if (!inv[1]) {
            inv[1] = 1; 
            for (int i = 2; i < N; ++i) inv[i] = mul(p - p / i, inv[p % i]);
        }
        Poly res(a); res.resize(len(a) + 1);
        for (int i = len(a); i; --i) res[i] = mul(res[i - 1], inv[i]);
        res[0] = 0; return res;
    }
    Poly Inv(const Poly &a) {
        Poly res(1, pow_mod(a[0], p - 2)); 
        int n = 1; while (n < len(a)) n <<= 1; 
        for (int k = 2; k <= n; k <<= 1) {
            int L = 2 * k; init_P(L); Poly t(L);
            copy_n(a.begin(), min(k, len(a)), t.begin()); 
            t.resize(L); res.resize(L);
            DIT(res); DIT(t);
            for (int i = 0; i < L; ++i) res[i] = mul(res[i], add(2, p - mul(t[i], res[i])));
            DIF(res); res.resize(k);
        } res.resize(len(a)); return res;
    }
    Poly Offset(const Poly &a, int c) {
        int n = len(a); init_C();
        Poly t1(n), t2(n);
        for (int i = 0; i < n; ++i) t1[i] = mul(pow_mod(c, i), inv[i]);
        for (int i = 0; i < n; ++i) t2[i] = mul(a[i], fac[i]);
        t1 = MMul(t1, t2);
        for (int i = 0; i < n; ++i) t1[i] = mul(t1[i], inv[i]);
        return t1; 
    }
    pair<Poly, Poly> Divide(const Poly &a, const Poly &b) {
        int n = len(a), m = len(b); 
        Poly t1(a.rbegin(), a.rbegin() + n - m + 1), t2(b.rbegin(), b.rend()); t2.resize(n - m + 1);
        Poly Q = Inv(t2) * t1; Q.resize(n - m + 1); reverse(Q.begin(), Q.end());
        Poly R = Q * b; R.resize(m - 1); for (int i = 0; i < len(R); ++i) R[i] = add(a[i], p - R[i]);
        return make_pair(Q, R); 
    }
    Poly Ln(const Poly &a) {
        Poly res = Int(Der(a) * Inv(a));
        res.resize(len(a)); return res;
    }
    Poly Exp(const Poly &a) {
        Poly res(1, 1);
        int n = 1; while (n < len(a)) n <<= 1;
        for (int k = 2; k <= n; k <<= 1) {
            Poly t(res.begin(), res.end()); t.resize(k); t = Ln(t);
            for (int i = 0; i < min(len(a), k); ++i) t[i] = add(a[i], p - t[i]); t[0] = add(t[0], 1);
            res = res * t; res.resize(k);
        } res.resize(len(a)); return res;
    }
    Poly Sqrt(const Poly &a) { // a[0] = 1
        Poly res(1, 1); ll inv2 = pow_mod(2, p - 2); 
        int n = 1; while (n < len(a)) n <<= 1;
        for (int k = 2; k <= n; k <<= 1) {
            Poly t(res.begin(), res.end()), ta(a.begin(), a.begin() + min(len(a), k));
            t.resize(k); t = Inv(t) * ta; 
            res.resize(k); for (int i = 0; i < k; ++i) res[i] = mul(add(res[i], t[i]), inv2);
        } res.resize(len(a)); return res;
    }
    Poly Pow(const Poly &a, int k) { // a[0] = 1
        return Exp(Ln(a) * k);
    }
    Poly Pow(const Poly &a, int k, int kk) { 
        int n = len(a), t = n, m, v, inv, powv; Poly res(n);
        for (int i = n - 1; ~i; --i) if (a[i]) t = i, v = a[i];
        if (k && t >= (n + k - 1) / k) return res;
        if (t == n) { if (!k) res[0] = 1; return res; }
        m = n - t * k; res.resize(m);
        inv = pow_mod(v, p - 2); powv = pow_mod(v, kk); 
        for (int i = 0; i < m; ++i) res[i] = mul(a[i + (k > 0) * t], inv);
        res = Exp(Ln(res) * k); res.resize(n); 
        for (int i = m - 1; ~i; --i) {
            int tmp = mul(res[i], powv);
            res[i] = 0, res[i + t * k] = tmp;
        }
        return res;
    }
}  // namespace Pol

int n;

struct Edge {
    int to, next;
} e[maxn * 2]; int c1, head[maxn];
inline void add_edge(int u, int v) {
    e[c1].to = v; e[c1].next = head[u]; head[u] = c1++;
}

int sz[maxn], son[maxn], fa[maxn];
void pre(int u, int fa) {
    int Max = 0; sz[u] = 1; 
    for (int i = head[u]; ~i; i = e[i].next) {
        int v = e[i].to; if (v == fa) continue;
        pre(v, u); sz[u] += sz[v];
        if (sz[v] > Max) Max = sz[v], son[u] = v;
    } if (son[u]) ::fa[son[u]] = u; 
}

Poly solve(int l, int r, vector<Poly> &vec) {
    if (l == r) return vec[l];
    int m = l + r >> 1;
    return Pol::operator*(solve(l, m, vec), solve(m + 1, r, vec)); 
}

pair<Poly, Poly> Solve(int l, int r, vector<Poly> &vec) {
    if (l == r) return make_pair(Poly { 0, 1 }, vec[l]);
    int m = l + r >> 1; auto [Fl, Gl] = Solve(l, m, vec); auto [Fr, Gr] = Solve(m + 1, r, vec);
    Poly F = Pol::operator *(Fr, Gl); if (len(F) < len(Fl)) F.resize(len(Fl));
    for (int i = 0; i < len(Fl); ++i) F[i] = add(F[i], Fl[i]);
    return make_pair(F, Pol::operator*(Gl, Gr)); 
}

Poly f[maxn], g[maxn];
void dfs(int u, int fa) {
    vector<Poly> vec;
    for (int i = head[u]; ~i; i = e[i].next) {
        int v = e[i].to; if (v == fa || v == son[u]) continue;
        dfs(v, u); vec.push_back(f[v]); 
    }
    if (vec.size()) g[u] = solve(0, vec.size() - 1, vec);
    else g[u] = Poly { 1 };
    if (son[u]) dfs(son[u], u); if (::fa[u]) return ;
    int x = u; vec.clear(); vec.push_back(g[u]); 
    while (son[x]) vec.push_back(g[x = son[x]]);
    auto [F, G] = Solve(0, vec.size() - 1, vec);
    f[u] = F; if (len(f[u]) < len(G)) f[u].resize(len(G));
    for (int i = 0; i < len(G); ++i) f[u][i] = add(f[u][i], G[i]);
}

int main() { fill(head, head + maxn, -1); 
    ios::sync_with_stdio(false);
    cin.tie(nullptr); cout.tie(nullptr);

    cin >> n;
    for (int i = 2, x; i <= n; ++i) cin >> x, add_edge(x, i);
    pre(1, 0); dfs(1, 0); f[1].resize(n + 1);
    for (int i = 1; i <= n; ++i) cout << f[1][i] << "\n";
    return 0;
}