Luogu 4705 玩游戏

看见这个题依稀想起了$5$月月赛时候的事情，到现在仍然它感觉非常神仙。

游戏$k$次价值的期望答案

$$ans_k = \frac{1}{nm}\sum_{i = 1}^{n}\sum_{j = 1}^{n}(a_i + b_j)^k$$

二项式定理展开

$$ans_k=\frac{1}{nm}\sum_{i = 1}^{n}\sum_{j = 1}^{m}\sum_{t = 0}^{k}\binom{k}{t}a_i^tb_j^{k - t}$$

$$ = \frac{1}{nm}\sum_{t = 0}^{k}\binom{k}{t}\sum_{i = 1}^{n}a_i^t\sum_{j = 1}^{m}b_j^{k - t}$$

$$= \frac{k!}{nm}\frac{\sum_{i = 1}^{n}a_i^t}{t!}\frac{\sum_{j = 1}^{m}b_j^{k - t}}{(k - t)!}$$

容易发现这后面是一个卷积的形式。

我们设$A(x) = \frac{\sum_{i = 1}^{n}a_i^x}{x!}$，$B(x) = \frac{\sum_{i = 1}^{n}b_i^x}{x!}$，答案就变成了

$$\frac{k!}{nm}(A * B)(k)$$

现在考虑怎么算这个$\sum_{i = 1}^{n}a_i^k$。

不会了，点开题解

我们构造一个多项式$F(x) = \prod_{i = 1}^{n}(1 - a_ix)$，这个$F(x)$可以通过分治算出来，时间复杂度$T(n) = 2T(\frac{n}{2}) + O(nlogn)$趋向$O(nlogn)$？？？。

接下来要开始变魔术了，

设$G(x) = lnF(x)$，

$$G(x) = \sum_{i = 1}^{n}ln(1 - a_ix)$$

对里面的$ln$在$x_0 = 0$处泰勒展开。

我们知道

$$ln(1 - x) = 0 - \frac{x}{1} - \frac{x^2}{2} - \frac{x^3}{3} - \cdots = -\sum_{i = 1}^{\infty}\frac{x^i}{i}$$

所以

$$G(x) = \sum_{i = 1}^{n}\sum_{j = 1}^{k}-\frac{a_i^j}{j}x^j$$

因为这个题对$x^{k + 1}$次取模了，所以后面的项可以不用再写了。

变形一下

$$G(x) = \sum_{j = 1}^{k}(-\frac{1}{j}\sum_{i = 1}^{n}a_i^j)x^j$$

发现$1$到$k$的$\sum_{i = 1}^{n}a_i^k$直接算出来了，而$i = 0$时候这东西显然为$n$。

鼓掌~~~

现在回过头来考虑一下这个魔术是怎么变出来的。

考虑构造每一个$a_i$的生成函数

$$1 + a_ix + a_i^2x^2 + a_i^3x^3 + \cdots$$

把每一个$a_i$的生成函数都构造出来然后加起来的第$i$项系数就是$k = i$时候的答案了。

$$F(x) = \sum_{i = 1}^{n}\frac{1}{1 - a_ix}$$

发现这个$F(x)$并不是很好算，而

$$ln'(1 - a_ix) = \frac{1}{1 - a_ix}$$

$$(ln(1 - a_ix))' = \frac{-a_i}{1 - a_ix}$$

所以先计算

$$G(x) = \sum_{i = 1}^{n}\frac{-a_i}{1 - a_ix} = (ln\prod_{i = 1}^{n}(1 - a_ix))'$$

把这两个式子写回到生成函数的形式，发现

$$F(x) = -x * G(x) + n$$

于是大功告成。

用$vector$写多项式真爽。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector <ll> poly;

const int N = 1e5 + ;
const int Maxn = 1e5;

int n, m, K;
ll a[N], b[N], fac[N], ifac[N], inv[N];

template <typename T>
inline void read(T &X) {
    X = ; char ch = ; T op = ;
    for (; ch > '' || ch < ''; ch = getchar())
        if (ch == '-') op = -;
    for (; ch >= '' && ch <= ''; ch = getchar())
        X = (X << ) + (X << ) + ch - ;
    X *= op;
}

inline void deb(poly c) {
    for (int i = ; i < (int)c.size(); i++)
        printf("%lld%c", c[i], " \n"[i == (int)c.size() - ]);
}

namespace Poly {
    const int L =  << ;
    const ll P = 998244353LL;

    int lim, pos[L];

    inline ll fpow(ll x, ll y) {
        ll res = ;
        for (; y > ; y >>= ) {
            if (y & ) res = res * x % P;
            x = x * x % P;
        }
        return res;
    }

    template <typename T>
    inline void inc(T &x, T y) {
        x += y;
        if (x >= P) x -= P;
    }

    template <typename T>
    inline void sub(T &x, T y) {
        x -= y;
        if (x < ) x += P;
    }

    inline void prework(int len) {
        int l = ;
        for (lim = ; lim < len; lim <<= , ++l);
        for (int i = ; i < lim; i++)
            pos[i] = (pos[i >> ] >> ) | ((i & ) << (l - ));
    }

    inline void ntt(poly &c, int opt) {
        c.resize(lim, );
        for (int i = ; i < lim; i++)
            if (i < pos[i]) swap(c[i], c[pos[i]]);
        for (int i = ; i < lim; i <<= ) {
            ll wn = fpow(, (P - ) / (i << ));
            if (opt == -) wn = fpow(wn, P - );
            for (int len = i << , j = ; j < lim; j += len) {
                ll w = ;
                for (int k = ; k < i; k++, w = w * wn % P) {
                    ll x = c[j + k], y = w * c[j + k + i] % P;
                    c[j + k] = (x + y) % P, c[j + k + i] = (x - y + P) % P;
                }
            }
        }

        if (opt == -) {
            ll inv = fpow(lim, P - );
            for (int i = ; i < lim; i++) c[i] = c[i] * inv % P;
        }
    }

    inline poly operator * (const poly &x, const poly &y) {
        poly res, u = x, v = y;
        prework(u.size() + v.size() - );
        ntt(u, ), ntt(v, );
        for (int i = ; i < lim; i++) res.push_back(v[i] * u[i] % P);
        ntt(res, -);
        res.resize(u.size() + v.size() - );
        return res;
    }

    poly getInv(poly x, int len) {
        x.resize(len);
        if (len == ) {
            poly res;
            res.push_back(x[]);
            return res;
        }
        poly y = getInv(x, (len + ) >> );
        prework(len << );

        poly u = x, v = y, res;
        ntt(u, ), ntt(v, );
        for (int i = ; i < lim; i++) res.push_back(v[i] * (2LL - u[i] * v[i] % P + P) % P);
        ntt(res, -);

        res.resize(len);
        return res;
    }

    inline void direv(poly &c) {
        for (int i = ; i < (int)c.size() - ; i++)
            c[i] = c[i + ] * (i + ) % P;
        c[c.size() - ] = ;
    }

    inline void integ(poly &c) {
        for (int i = (int)c.size() - ; i > ; i--)
            c[i] = c[i - ] * inv[i] % P;
        c[] = ;
    }

    inline poly getLn(poly c) {
        poly a = getInv(c, (int)c.size());
        poly b = c;
        direv(b);

        poly res = b * a;
        res.resize(c.size());
        integ(res);
        return res;
    }

    inline poly solve(int l, int r, ll *c) {
        if (l == r) {
            poly res;
            res.push_back(), res.push_back((P - c[l]) % P);
            return res;
        }

        int mid = ((l + r) >> );
        poly u = solve(l, mid, c), v = solve(mid + , r, c);
        poly res = u * v;
        res.resize(u.size() + v.size() - );
        return res;
    }

    inline poly mul(const poly &x, const poly &y) {
        return x * y;
    }

}

using Poly::P;
using Poly::fpow;
using Poly::inc;
using Poly::sub;
using Poly::solve;
using Poly::getLn;

inline void prework() {
    fac[] = inv[] = inv[] = ;
    for (int i = ; i <= Maxn; i++) {
        fac[i] = fac[i - ] * i % P;
        if (i > ) inv[i] = (P - P / i) * inv[P % i] % P;
    }
    ifac[Maxn] = fpow(fac[Maxn], P - );
    for (int i = Maxn - ; i >= ; i--) ifac[i] = ifac[i + ] * (i + ) % P;
}

int main() {
/*    #ifndef ONLINE_JUDGE
        freopen("Sample.txt", "r", stdin);
    #endif    */

    freopen("input.txt", "r", stdin);
    freopen("my.out", "w", stdout);

    prework();

    read(n), read(m);
    for (int i = ; i <= n; i++) read(a[i]);
    for (int i = ; i <= m; i++) read(b[i]);
    read(K);
    ++K;

    poly Fa = solve(, n, a), Fb = solve(, m, b);

//    deb(Fa), deb(Fb);

    Fa.resize(K, ), Fb.resize(K, );
    poly Ga = getLn(Fa), Gb = getLn(Fb);

    Ga.resize(K, ), Gb.resize(K, );

//    deb(Ga), deb(Gb);

    poly A, B, C;

    A.push_back(n), B.push_back(m);
    for (int i = ; i < K; i++) {
        A.push_back((P - Ga[i]) % P * i % P * ifac[i] % P);
        B.push_back((P - Gb[i]) % P * i % P * ifac[i] % P);
    }

//    deb(A), deb(B);

    C = Poly::mul(A, B);
    C.resize(K);

//    deb(C);

//    printf("\n");
    ll invn = fpow(n, P - ), invm = fpow(m, P - );
    for (int i = ; i < K; i++)
        printf("%lld\n", invn * invm % P * fac[i] % P * C[i] % P);

    return ;
}