积的和典型

对于所有长度为 $n$ 且总和为 $m$ 的任意正整数序列 $a$，求 $\sum\prod a_i \bmod~ 998244353$ 。

限制：

• $1 \leqslant n, m \leqslant 2 \times 10^5$

算法分析

做法一：积的和典型

一方面，满足 $\sum a_i = m$ 的正整数序列个数，可以考虑在 $m$ 个白球中插入 $n-1$ 个隔板，那么就会得到 $n$ 个区间

另一方面，$\prod a_i$ 可以理解为在每个区间中任选一个球（不妨将这个球染成红色）的方案数，因为不同区间的选法是独立的，所以是乘法

然后将这二者综合起来考虑，不妨把隔板换成红球（不会影响上面的选法数），这样就得到 $n+m-1$ 个球，且其中有 $2n-1$ 个红球，那么总方案数就是 $\binom{n+m-1}{2n-1}$

（更喜欢这种做法，虽然理解起来会比较困难）

做法二：生成函数

写成生成函数的式子就是 $[x^m](x + 2x^2 + 3x^3 + \cdots)^n$

记 $f(x) = x + 2x^2 + 3x^3 + \cdots$
$\begin{aligned} (1-x)f(x) &= (x + 2x^2 + 3x^3 + \cdots) - (x^2 + 2x^3 + 3x^4 + \cdots)\\ &= x + x^2 + x^3 + \cdots\\ &= \frac{x}{1-x} \end{aligned}$

$\Rightarrow ~ f(x) = \frac{x}{(1-x)^2}$

于是，$[x^m]f(x)^n = [x^m]\frac{x^n}{(1-x)^{2n}} = [x^{m-n}]\frac{1}{(1-x)^{2n}}$

这个值可以用负数的二项式写成 $(-1)^{m-n}\binom{-2n}{m-n}$

一般地，我们有 $\binom{-n}{k} = (-1)^k\binom{n+k-1}{k}$

所以，$(-1)^{m-n}\binom{-2n}{m-n} = \binom{m+n-1}{m-n} = \binom{m+n-1}{2n-1}$ 。

代码实现

#include <bits/stdc++.h>
 
using namespace std;
using ll = long long;
 
const int mod = 998244353;
//const int mod = 1000000007;
struct mint {
    ll x;
    mint(ll x=0):x((x%mod+mod)%mod) {}
    mint operator-() const {
        return mint(-x);
    }
    mint& operator+=(const mint a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const mint a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint a) const {
        return mint(*this) += a;
    }
    mint operator-(const mint a) const {
        return mint(*this) -= a;
    }
    mint operator*(const mint a) const {
        return mint(*this) *= a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
 
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint a) {
        return *this *= a.inv();
    }
    mint operator/(const mint a) const {
        return mint(*this) /= a;
    }
};
istream& operator>>(istream& is, mint& a) {
    return is >> a.x;
}
ostream& operator<<(ostream& os, const mint& a) {
    return os << a.x;
}
 
struct modinv {
  int n; vector<mint> d;
  modinv(): n(2), d({0,1}) {}
  mint operator()(int i) {
    while (n <= i) d.push_back(-d[mod%n]*(mod/n)), ++n;
    return d[i];
  }
  mint operator[](int i) const { return d[i];}
} invs;
struct modfact {
  int n; vector<mint> d;
  modfact(): n(2), d({1,1}) {}
  mint operator()(int i) {
    while (n <= i) d.push_back(d.back()*n), ++n;
    return d[i];
  }
  mint operator[](int i) const { return d[i];}
} facts;
struct modfactinv {
  int n; vector<mint> d;
  modfactinv(): n(2), d({1,1}) {}
  mint operator()(int i) {
    while (n <= i) d.push_back(d.back()*invs(n)), ++n;
    return d[i];
  }
  mint operator[](int i) const { return d[i];}
} ifacts;
mint comb(int n, int k) {
  if (n < k || k < 0) return 0;
  return facts(n)*ifacts(k)*ifacts(n-k);
}
 
int main() {
    int n, m;
    cin >> n >> m;
    
    mint ans = comb(m+n-1, 2*n-1);
    cout << ans << '\n';
    
    return 0;
}