[2021CCPC 威海G] Shinyruo and KFC (下降幂多项式乘法+下降幂转普通幂+多项式多点求值)

于 2022-10-04 15:22:49 发布
阅读量816 收藏
点赞数 1
分类专栏： 数论题 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/messywind/article/details/127162620
版权

题意

给定 n n n 个正整数 a 1 , a 2 , ⋯   , a n a_1,a_2,\cdots,a_n a1​,a2​,⋯,an​，并给定正整数 m m m，对于每个 k ∈ [ 1 , m ] k \in [1, m] k∈[1,m]，计算 ∏ i = 1 n ( k a i ) \prod\limits_{i = 1} ^ {n} \dbinom{k}{a_i} i=1∏n​(ai​k​)

对 998   244   353 998\,244\,353 998244353 取模。

( 1 ≤ n , m ≤ 5 × 1 0 4 , ∑ i = 1 n a i ≤ 1 0 5 ) (1 \le n, m \le 5 \times 10 ^ 4, \sum\limits_{i = 1} ^ {n}a_i \le 10 ^ 5) (1≤n,m≤5×104,i=1∑n​ai​≤105)

分析：

考虑拆组合数
∏ i = 1 n ( k a i ) = ∏ i = 1 n k ! a i ! × ( k − a i ) ! = 1 ∏ i = 1 n a i ! × ∏ i = 1 n k a i ‾ \prod_{i = 1} ^ {n}\binom{k}{a_i}=\prod_{i = 1} ^ {n}\frac{k!}{a_i! \times (k - a_i)!} \\ = \frac{1}{\prod\limits_{i = 1} ^ {n}a_i!} \times \prod_{i = 1} ^ {n} k ^ {\underline {a_i}} i=1∏n​(ai​k​)=i=1∏n​ai​!×(k−ai​)!k!​=i=1∏n​ai​!1​×i=1∏n​kai​​
所以可以把 k a i ‾ k ^ {\underline{a_i}} kai​​ 看作一个下降幂多项式，那么使用分治下降幂多项式乘法可以求出 ∏ i = 1 n k a i ‾ \prod\limits_{i = 1} ^ {n} k ^ {\underline {a_i}} i=1∏n​kai​​，再转为普通幂多项式，再对 ( 1 , 2 , ⋯   , m ) (1, 2, \cdots,m) (1,2,⋯,m) 使用多项式多点求值即可求出答案，时间复杂度 O ( n log ⁡ 2 n ) O(n\log ^ 2 n) O(nlog2n)

代码：

#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
constexpr int mod = 998244353;
template<class T>
T power(T a, int b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}
template<int mod>
struct ModInt {
    int x;
    ModInt() : x(0) {}
    ModInt(i64 y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
    ModInt &operator+=(const ModInt &p) {
        if ((x += p.x) >= mod) x -= mod;
        return *this;
    }
    ModInt &operator-=(const ModInt &p) {
        if ((x += mod - p.x) >= mod) x -= mod;
        return *this;
    }
    ModInt &operator*=(const ModInt &p) {
        x = (int)(1LL * x * p.x % mod);
        return *this;
    }
    ModInt &operator/=(const ModInt &p) {
        *this *= p.inv();
        return *this;
    }
    ModInt operator-() const {
        return ModInt(-x);
    }
    ModInt operator+(const ModInt &p) const {
        return ModInt(*this) += p;
    }
    ModInt operator-(const ModInt &p) const {
        return ModInt(*this) -= p;
    }
    ModInt operator*(const ModInt &p) const {
        return ModInt(*this) *= p;
    }
    ModInt operator/(const ModInt &p) const {
        return ModInt(*this) /= p;
    }
    bool operator==(const ModInt &p) const {
        return x == p.x;
    }
    bool operator!=(const ModInt &p) const {
        return x != p.x;
    }
    ModInt inv() const {
        int a = x, b = mod, u = 1, v = 0, t;
        while (b > 0) {
            t = a / b;
            swap(a -= t * b, b);
            swap(u -= t * v, v);
        }
        return ModInt(u);
    }
    ModInt pow(i64 n) const {
        ModInt res(1), mul(x);
        while (n > 0) {
            if (n & 1) res *= mul;
            mul *= mul;
            n >>= 1;
        }
        return res;
    }
    friend ostream &operator<<(ostream &os, const ModInt &p) {
        return os << p.x;
    }
    friend istream &operator>>(istream &is, ModInt &a) {
        i64 t;
        is >> t;
        a = ModInt<mod>(t);
        return (is);
    }
    int val() const {
        return x;
    }
    static constexpr int val_mod() {
        return mod;
    }
};
using Z = ModInt<mod>;
vector<Z> fact, infact;
void init(int n) {
    fact.resize(n + 1), infact.resize(n + 1);
    fact[0] = infact[0] = 1;
    for (int i = 1; i <= n; i ++) {
        fact[i] = fact[i - 1] * i;
    }
    infact[n] = fact[n].inv();
    for (int i = n; i; i --) {
        infact[i - 1] = infact[i] * i;
    }
}
Z C(int n, int m) {
    if (n < 0 || m < 0 || n < m) return Z(0);
    return fact[n] * infact[n - m] * infact[m];
}
vector<int> rev;
vector<Z> roots{0, 1};
void dft(vector<Z> &a) {
    int n = a.size();
    if (int(rev.size()) != n) {
        int k = __builtin_ctz(n) - 1;
        rev.resize(n);
        for (int i = 0; i < n; i ++) {
            rev[i] = rev[i >> 1] >> 1 | (i & 1) << k;
        }
    }
    for (int i = 0; i < n; i ++) {
        if (rev[i] < i) {
            swap(a[i], a[rev[i]]);
        }
    }
    if (int(roots.size()) < n) {
        int k = __builtin_ctz(roots.size());
        roots.resize(n);
        while ((1 << k) < n) {
            Z e = power(Z(3), (mod - 1) >> (k + 1));
            for (int i = 1 << (k - 1); i < (1 << k); i ++) {
                roots[i << 1] = roots[i];
                roots[i << 1 | 1] = roots[i] * e;
            }
            k ++;
        }
    }
    for (int k = 1; k < n; k *= 2) {
        for (int i = 0; i < n; i += 2 * k) {
            for (int j = 0; j < k; j ++) {
                Z u = a[i + j], v = a[i + j + k] * roots[k + j];
                a[i + j] = u + v, a[i + j + k] = u - v;
            }
        }
    }
}
void idft(vector<Z> &a) {
    int n = a.size();
    reverse(a.begin() + 1, a.end());
    dft(a);
    Z inv = (1 - mod) / n;
    for (int i = 0; i < n; i ++) {
        a[i] *= inv;
    }
}
struct Poly {
    vector<Z> a;
    Poly() {}
    Poly(const vector<Z> &a) : a(a) {}
    Poly(const initializer_list<Z> &a) : a(a) {}
    int size() const {
        return a.size();
    }
    void resize(int n) {
        a.resize(n);
    }
    Z operator[](int idx) const {
        if (idx < size()) {
            return a[idx];
        } else {
            return 0;
        }
    }
    Z &operator[](int idx) {
        return a[idx];
    }
    Poly mulxk(int k) const {
        auto b = a;
        b.insert(b.begin(), k, 0);
        return Poly(b);
    }
    Poly modxk(int k) const {
        k = min(k, size());
        return Poly(vector<Z>(a.begin(), a.begin() + k));
    }
    Poly divxk(int k) const {
        if (size() <= k) {
            return Poly();
        }
        return Poly(vector<Z>(a.begin() + k, a.end()));
    }
    friend Poly operator+(const Poly &a, const Poly &b) {
        vector<Z> res(max(a.size(), b.size()));
        for (int i = 0; i < int(res.size()); i ++) {
            res[i] = a[i] + b[i];
        }
        return Poly(res);
    }
    friend Poly operator-(const Poly &a, const Poly &b) {
        vector<Z> res(max(a.size(), b.size()));
        for (int i = 0; i < int(res.size()); i ++) {
            res[i] = a[i] - b[i];
        }
        return Poly(res);
    }
    friend Poly operator*(Poly a, Poly b) {
        if (a.size() == 0 || b.size() == 0) {
            return Poly();
        }
        int sz = 1, tot = a.size() + b.size() - 1;
        while (sz < tot) {
            sz *= 2;
        }
        a.a.resize(sz);
        b.a.resize(sz);
        dft(a.a);
        dft(b.a);
        for (int i = 0; i < sz; i ++) {
            a.a[i] = a[i] * b[i];
        }
        idft(a.a);
        a.resize(tot);
        return a;
    }
    friend Poly operator*(Z a, Poly b) {
        for (int i = 0; i < int(b.size()); i ++) {
            b[i] *= a;
        }
        return b;
    }
    friend Poly operator*(Poly a, Z b) {
        for (int i = 0; i < int(a.size()); i ++) {
            a[i] *= b;
        }
        return a;
    }
    Poly &operator+=(Poly b) {
        return (*this) = (*this) + b;
    }
    Poly &operator-=(Poly b) {
        return (*this) = (*this) - b;
    }
    Poly &operator*=(Poly b) {
        return (*this) = (*this) * b;
    }
    Poly deriv() const {
        if (a.empty()) {
            return Poly();
        }
        vector<Z> res(size() - 1);
        for (int i = 0; i < size() - 1; i ++) {
            res[i] = a[i + 1] * (i + 1);
        }
        return Poly(res);
    }
    Poly integr() const {
        vector<Z> res(size() + 1);
        for (int i = 0; i < size(); i ++) {
            res[i + 1] = a[i] / (i + 1);
        }
        return Poly(res);
    }
    Poly inv(int m) const {
        Poly x{a[0].inv()};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x * (Poly{2} - modxk(k) * x)).modxk(k);
        }
        return x.modxk(m);
    }
    Poly log(int m) const {
        return (deriv() * inv(m)).integr().modxk(m);
    }
    Poly exp(int m) const {
        Poly x{1};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x * (Poly{1} - x.log(k) + modxk(k))).modxk(k);
        }
        return x.modxk(m);
    }
    Poly pow(int k, int m) const {
        int i = 0;
        while (i < size() && a[i].val() == 0) {
            i ++;
        }
        if (i == size() || 1LL * i * k >= m) {
            return Poly(vector<Z>(m));
        }
        Z v = a[i];
        auto f = divxk(i) * v.inv();
        return (f.log(m - i * k) * k).exp(m - i * k).mulxk(i * k) * power(v, k);
    }
    Poly sqrt(int m) const {
        Poly x{1};
        int k = 1;
        while (k < m) {
            k *= 2;
            x = (x + (modxk(k) * x.inv(k)).modxk(k)) * ((mod + 1) / 2);
        }
        return x.modxk(m);
    }
    Poly mulT(Poly b) const {
        if (b.size() == 0) {
            return Poly();
        }
        int n = b.size();
        reverse(b.a.begin(), b.a.end());
        return ((*this) * b).divxk(n - 1);
    }
    vector<Z> eval(vector<Z> x) const {
        if (size() == 0) {
            return vector<Z>(x.size(), 0);
        }
        const int n = max(int(x.size()), size());
        vector<Poly> q(n << 2);
        vector<Z> ans(x.size());
        x.resize(n);
        function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                q[p] = Poly{1, -x[l]};
            } else {
                int m = l + r >> 1;
                build(p << 1, l, m);
                build(p << 1 | 1, m, r);
                q[p] = q[p << 1] * q[p << 1 | 1];
            }
        };
        build(1, 0, n);
        function<void(int, int, int, const Poly &)> work = [&](int p, int l, int r, const Poly &num) {
            if (r - l == 1) {
                if (l < int(ans.size())) {
                    ans[l] = num[0];
                }
            } else {
                int m = (l + r) / 2;
                work(p << 1, l, m, num.mulT(q[p << 1 | 1]).modxk(m - l));
                work(p << 1 | 1, m, r, num.mulT(q[p << 1]).modxk(r - m));
            }
        };
        work(1, 0, n, mulT(q[1].inv(n)));
        return ans;
    }
    Poly inter(const Poly &y) const {
        vector<Poly> Q(a.size() << 2), P(a.size() << 2);
        function<void(int, int, int)> dfs1 = [&](int p, int l, int r) {
            int m = l + r >> 1;
            if (l == r) {
                Q[p].a.push_back(-a[m]);
                Q[p].a.push_back(Z(1));
                return;
            }
            dfs1(p << 1, l, m), dfs1(p << 1 | 1, m + 1, r);
            Q[p] = Q[p << 1] * Q[p << 1 | 1];
        };
        dfs1(1, 0, a.size() - 1);
        Poly f;
        f.a.resize((int)(Q[1].size()) - 1);
        for (int i = 0; i + 1 < Q[1].size(); i ++) {
            f[i] = Q[1][i + 1] * (i + 1);
        }
        Poly g = f.eval(a);
        function<void(int, int, int)> dfs2 = [&](int p, int l, int r) {
            int m = l + r >> 1;
            if (l == r) {
                P[p].a.push_back(y[m] * power(g[m], mod - 2));
                return;
            }
            dfs2(p << 1, l, m), dfs2(p << 1 | 1, m + 1, r);
            P[p].a.resize(r - l + 1);
            Poly A = P[p << 1] * Q[p << 1 | 1];
            Poly B = P[p << 1 | 1] * Q[p << 1];
            for (int i = 0; i <= r - l; i ++) {
                P[p][i] = A[i] + B[i];
            }
        };
        dfs2(1, 0, a.size() - 1);
        return P[1];
    }
};
Poly toFPP(vector<Z> &a) {
    int n = a.size();
    vector<Z> b(n);
    iota(b.begin(), b.end(), 0);
    auto F = Poly(a).eval(b);
    vector<Z> f(n), g(n);
    for (int i = 0, sign = 1; i < n; i ++, sign *= -1) {
        f[i] = F[i] * infact[i];
        g[i] = Z(sign) * infact[i];
    }
    return Poly(f) * Poly(g);
}
Poly toOP(vector<Z> &a) {
    int n = a.size();
    vector<Z> g(n);
    for (int i = 0; i < n; i ++) {
        g[i] = infact[i];
    }
    auto F = Poly(a) * Poly(g);
    for (int i = 0; i < n; i ++) {
        F[i] *= fact[i];
    }
    vector<Z> p(n);
    iota(p.begin(), p.end(), 0);
    return Poly(p).inter(F);
}
Poly FPPMul(Poly a, Poly b) {
    int n = a.size() + b.size() - 1;
    Poly p;
    p.resize(n);
    for (int i = 0; i < n; i ++) {
        p[i] = infact[i];
    }
    a *= p, b *= p;
    for (int i = 0; i < n; i ++) {
        a[i] *= b[i] * fact[i];
    }
    for (int i = 1; i < n; i += 2) {
        p[i] = -p[i];
    }
    a *= p;
    a.resize(n);
    return a;
}
signed main() {
    init(2e5);
    cin.tie(0) -> sync_with_stdio(0);
    int n, m;
    cin >> n >> m;
    Z inv = 1;
    vector<int> a(n + 1);
    vector<vector<Z>> num(n + 1);
    for (int i = 1; i <= n; i ++) {
        cin >> a[i];
        inv *= infact[a[i]];
        num[i].resize(a[i] + 1);
        num[i][a[i]] = 1;
    }
    function<Poly(int, int)> dc = [&](int l, int r) {
        if (l == r) {
            return Poly(num[l]);
        }
        int mid = l + r >> 1;
        return FPPMul(dc(l, mid), dc(mid + 1, r));
    };
    vector<Z> q(m + 1);
    iota(q.begin(), q.end(), 0);
    auto ans = dc(1, n).a;
    auto res = toOP(ans).eval(q);
    for (int i = 1; i <= m; i ++) {
        cout << res[i] * inv << "\n";
    }
}
凌乱之风
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021CCPC威海热身赛_Problem C. Count（csdn）————程序.pdf
12-01
2. 接下来的T行中，每两行分别代表Zayin和Taotao能识别的数字数组A和B，每个数组有10个布尔值。如果A[i]或B[i]为1（索引从0开始），则对应的人能识别阿拉伯数字i；否则，他们无法识别。 3. 每组测试用例的第三行给出...
斯特林数
Joker's blog
03-05 412
斯特林数 第一类斯特林数 将nnn个(区分)物品分成mmm个(不区分)非空环排列的方案数 递推式O(nm)O(nm)O(nm) [n+1m]=n×[nm]+[nm−1][n+1m]=n×[nm]+[nm−1]\left[\begin{array}{c}n+1\\m\end{array}\right] = n\times\left[\begin{array}{c}n\\m\end{a...
学习笔记第十六节：斯特林数
Deep_Kevin的娱乐空间
06-28 475
​正题 第一类斯特林数 s(n,k)s(n,k)s(n,k) 表示把 nnn 个数放进不分种类的 kkk 个非空的圆中的排列数。 递推式为 s(n,k)=s(n−1,k−1)+(n−1)∗s(n−1,k)s(n,k)=s(n-1,k-1)+(n-1)*s(n-1,k)s(n,k)=s(n−1,k−1)+(n−1)∗s(n−1,k) 。 s(n−1,k−1)s(n-1,k-1)s(n−1,k−1) 表示的是前 n−1n-1n−1 个排列成 k−1k-1k−1 个圆后，第 nnn 个自己成为一个独立的圆。 (n
CCPC 2021威海 - G. Shinyruo and KFC（组合数，小技巧）
Mr_dimple的博客
07-05 1002
题意 一共有 nnn 种食物，每种食物有 aia_iai​ 个。食物个数总和不超过 10510^5105。 现在要把这些食物分给 kkk 个人，每个人可以拿多种事物，但每种食物最多拿 1 个。 对于 kkk 从 1 到 mmm，分别输出食物分配方案。 答案模 998244353998244353998244353。 1≤m,n≤5⋅1041 \le m,n \le 5 \cdot 10^41≤m,n≤5⋅104 0≤ai≤105, ∑i=1nai≤1050\le a_i\le 10^5,\ \sum_{i=
洛谷P5393 【模板】下降幂多项式转普通多项式（多项式快速插值）
苟为蒟蒻又何妨
08-03 487
传送门 已知下降幂多项式A(x)=∑i=0naixi‾A(x)=\sum_{i=0}^na_ix^{\underline i}A(x)=∑i=0n​ai​xi​ 现在求普通多项式B(x)=∑i=0nbixiB(x)=\sum_{i=0}^nb_ix^iB(x)=∑i=0n​bi​xi使得A(x)=B(x)A(x)=B(x)A(x)=B(x) 思路： 考虑先ffpffpffp转点值，然后快速插值即可...
专题讲座5 组合数学 学习心得
fanshui682的博客
07-22 379
组合数学和逆元的关系很密切
最小割 ---- 2021 ccpc 威海 H city-safety(最大利润 = 最大收益 - 最小花费(最小.pdf
12-05
本题是2021年CCPC威海站H题“city-safety”，属于树形动态规划和最小割问题的结合。题目给出一棵树，树上的每个节点都有一定的花费`w_i`，如果加强某个节点，其距离不超过`p`的所有节点都会得到收益`v_p`。目标是...
2021_CCPC_online_contest.pdf
09-03
CCPC网络挑战赛2021
2021CCPC华为云挑战赛.pdf
08-21
2021CCPC华为云挑战赛.pdf
2021 CCPC 桂林站正式赛题目
最新发布
04-19
CCPC 中国大学生程序设计竞赛（China Collegiate Programming Contest， CCPC）是由教育部高等学校计算机类专业教学指导委员会主办的面向全国高校大学生的年度学科竞赛 ，旨在激发学生学习计算机领域专业知识与技能...
The 2021 CCPC Weihai Onsite(vp补题记录,A,J,D,G)
qq_49593247的博客
09-07 766
就是每一次询问为i(1
【BJOI2019】勘破神机（下降幂转自然幂）（第一类斯特林数）（特征方程）
zxyoi_dreamer的博客（不定期诈尸）
10-18 320
传送门 题解： 完全自己推出来的第一道数学神题。 首先我们知道宽度为222的部分方案数是斐波那契数列。 设fnf_nfn​表示长度为nnn的时候方案数，题目要求的实际上是这个东西： ∑n=lr(fnk)\sum_{n=l}^r{f_n\choose k}n=l∑r​(kfn​​) 看上去非常地不可做，考虑表示成下降幂的形式，然后利用第一类斯特林数直接转成自然幂，直接上通项公式，然后利用二项式定理...
【LuoguP5383】[模板]普通多项式转下降幂多项式
Yu Gi Oh!
05-17 1289
传送门 Sol (怎么老是有人喜欢出新的多项式毒瘤板子,懒得整到一起了) 核心就是把 幂用下降幂来代替。 使用斯特林数展开幂为下降幂: xn=∑i=0n(xi)i!S(n,i)=∑i=0nS(n,i)xi‾x^n=\sum_{i=0}^n{x\choose i}i!S(n,i)=\sum_{i=0}^nS(n,i)x^{\underline i}xn=i=0∑n​(ix​)i!S(n,i)=i=0...
普通多项式转下降幂多项式小结
a_forever_dream的博客
07-02 694
前置芝士 斯特林数 正题 对于给定的多项式 F(x)=∑i=0naixiF(x)=\sum_{i=0}^n a_i x^iF(x)=∑i=0n​ai​xi，求出一个下降幂多项式 G(x)=∑i=0nbixi‾G(x)=\sum_{i=0}^n b_i x^{\underline i}G(x)=∑i=0n​bi​xi​，满足 F(x)=G(x)F(x)=G(x)F(x)=G(x)。 主要用到的技巧就是利用第二类斯特林数展开 xnx^nxn，即 xn=∑j=0nCxjj!S(n,j)x^n=\sum_{j=
【模板】【洛谷P5393】下降幂多项式转普通多项式（拉格朗日插值）（NTT）
zxyoi_dreamer的博客（不定期诈尸）
08-15 249
传送门 题解： 首先对于下降幂多项式，其系数表达的点值EGF只需要乘上一个exe^xex。 于是我们得到了若干个点值，直接份治拉格朗日插值即可。 代码： #include<bits/stdc++.h> #define ll long long #define re register #define cs const using std::cerr; using std::cout...
[2021CCPC 威海M] 810975 (组合计数 容斥原理 多项式快速幂)
messywind的博客
12-08 1898
题意 夜吹下了 nnn 盘酒馆战旗，吃了 mmm 次鸡，并且 kkk 连鸡，求方案数对 998244353998244353998244353 取模。 分析： 已知下了 nnn 盘棋，吃了 mmm 次鸡，所以有 n−mn - mn−m 局是未吃鸡的，所以考虑把 mmm 次鸡插空，n−mn - mn−m 局未吃鸡局有 n−m+1n - m + 1n−m+1 个空位，那么每个空的生成函数为 1+x+x2+x3+⋯+xk 1+x+x^2+x^3+\cdots+x^k 1+x+x2+x3+⋯+xk 所以所有的方案数
[2021 CCCC天梯赛] 可怜的简单题 (概率期望 莫比乌斯反演 杜教筛)
messywind的博客
09-23 1711
题意 每次从 [1,n][1,n][1,n] 中选择一个数加到一个序列末尾，当 gcd⁡(a1,⋯ ,an)=1\gcd(a_1,\cdots,a_n)=1gcd(a1​,⋯,an​)=1 时停止，求期望长度，对 ppp 取模 1≤n≤1011,n<p≤10121\le n \le 10^{11},n< p \le 10 ^{12}1≤n≤1011,n<p≤1012 分析： 设 E(len)E(len)E(len) 为期望长度，那么根据期望定义 E(len)=∑i=1∞P(len=i)⋅i
[2021CCPC威海热身赛] Number Theory (打表 推公式)
messywind的博客
11-20 952
题意 求 ∑k=1n∑i∣k∑j∣iλ(i)λ(j)\sum_{k = 1}^{n}\sum_{i \mid k} \sum_{j \mid i} \lambda(i) \lambda(j)k=1∑n​i∣k∑​j∣i∑​λ(i)λ(j) 对 998244353998244353998244353 取模 其中 λ(x)=(−1)∑iei,x=∏ipiei\lambda(x) = (-1)^{\sum\limits_{i}e_i},x=\prod\limits_{i}p_i^{e_i}λ(x)=(−1)i∑​
[AtCoder abc234 F] Reordering (EGF NTT)
messywind的博客
01-09 891
题意 给定一个长度为 nnn 的字符串 SSS，计算有多少种非空子序列的排列，对 998244353998244353998244353 取模。 1≤n≤5×1031 \le n \le 5\times 10^31≤n≤5×103 分析： 设 262626 个英文字母每个字母 uuu 的生成函数为（因为要计算排列，所以是 EGF\textbf{EGF}EGF） 1+11!x+12!x2+⋯+1cntu!xcntu 1 + \frac{1}{1!}x + \frac{1}{2!}x^2 + \cdots +
the 2021 ccpc guangzhou onsite
04-06
b'the 2021 ccpc guangzhou onsite'是指2021年中国大学生程序设计竞赛（CCPC）广州站的现场比赛。该比赛是中国最高水平的大学生程序设计竞赛之一，旨在促进大学生程序设计能力的提升和交流。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值