LOJ#2541 猎人杀

解：step1：猎人死了之后不下台，而是继续开枪，这样分母不变......

然后容斥，枚举猎人集合s，钦定他们在1之后死。定义打到1的时候结束，枚举游戏在i轮时结束。

发现式子是一个1 + x + x² + x³ + ... = 1 / (1 - x)

但是枚举子集不现实，发现值域很小，我们用小Z的礼物的套路，考虑计算每个值的容斥系数是多少。

然后就NTT加速了。预处理逆元卡常。

#include <bits/stdc++.h>

typedef long long LL;
typedef std::vector<int> Poly;

inline void read(int &x) {
    x = 0;
    char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - 48;
        c = getchar();
    }
    return;
}

const int N = 200010, MO = 998244353;

int A[N << 2], B[N << 2];
int r[N << 2], n, w[N], inv[N];

inline int qpow(int a, int b) {
    a = (a % MO + MO) % MO;
    int ans = 1;
    while(b) {
        if(b & 1) ans = 1ll * ans * a % MO;
        a = 1ll * a * a % MO;
        b = b >> 1;
    }
    return ans;
}

inline void prework(int n) {
    static int R = 0;
    if(R == n) return;
    R = n;
    int lm = 1;
    while((1 << lm) < n) lm++;
    for(register int i = 0; i < n; i++) r[i] = (r[i >> 1] >> 1) | ((i & 1) << (lm - 1));
    return;
}

inline void NTT(int *a, int n, int f) {
    prework(n);
    for(int i = 0; i < n; i++) {
        if(i < r[i]) std::swap(a[i], a[r[i]]);
    }
    for(register int len = 1; len < n; len <<= 1) {
        int Wn = qpow(3, (MO - 1) / (len << 1));
        if(f == -1) Wn = qpow(Wn, MO - 2);
        for(register int i = 0; i < n; i += (len << 1)) {
            int w = 1;
            for(register int j = 0; j < len; j++) {
                int t = 1ll * a[i + len + j] * w % MO;
                a[i + len + j] = (a[i + j] - t) % MO;
                a[i + j] = (a[i + j] + t) % MO;
                w = 1ll * w * Wn % MO;
            }
        }
    }
    if(f == -1) {
        LL inv = qpow(n, MO - 2);
        for(int i = 0; i < n; i++) {
            a[i] = 1ll * a[i] * inv % MO;
        }
    }
    return;
}

inline Poly mul(const Poly &a, const Poly &b) {
    int na = a.size(), nb = b.size(), n = na + nb - 1, len = 1;
    while(len < n) len <<= 1;
    for(register int i = 0; i < na; i++) A[i] = a[i];
    for(register int i = 0; i < nb; i++) B[i] = b[i];
    memset(A + na, 0, (len - na) * sizeof(LL));
    memset(B + nb, 0, (len - nb) * sizeof(LL));
    NTT(A, len, 1); NTT(B, len, 1);
    for(register int i = 0; i < len; i++) A[i] = 1ll * A[i] * B[i] % MO;
    NTT(A, len, -1);
    Poly ans(n);
    for(register int i = 0; i < n; i++) ans[i] = A[i];
    return ans;
}

Poly solve(int l, int r) {
    if(l == r) {
        Poly a(w[r] + 1);
        a[0] = 1; a[w[r]] = -1;
        return a;
    }
    int mid = (l + r) >> 1;
    return mul(solve(l, mid), solve(mid + 1, r));
}

int main() {
    int sum = 0;
    read(n);
    for(register int i = 1; i <= n; i++) {
        read(w[i]);
        sum += w[i];
    }

    inv[0] = inv[1] = 1;
    for(int i = 2; i <= sum; i++) {
        inv[i] = 1ll * inv[MO % i] * (MO - MO / i) % MO;
    }

    std::sort(w + 2, w + n + 1);
    Poly a = solve(2, n);

    int m = a.size();
    int ans = 0;
    for(register int i = 0; i < m; i++) {
        ans = (ans + 1ll * a[i] * inv[w[1] + i] % MO) % MO;
    }
    ans = 1ll * ans * w[1] % MO;
    printf("%d
", (ans + MO) % MO);
    return 0;
}