无限手套 分治 + NTT + 生成函数

最新推荐文章于 2022-04-07 12:56:03 发布
最新推荐文章于 2022-04-07 12:56:03 发布
阅读量330 收藏 1
点赞数
分类专栏： # 母函数 # 多项式 # 组合数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46173805/article/details/118805150
版权
组合数学 同时被 3 个专栏收录
15 篇文章 0 订阅
订阅专栏
多项式
12 篇文章 0 订阅
订阅专栏
母函数
11 篇文章 0 订阅
订阅专栏

无限手套

在这里插入图片描述

solution

∏ k = 0 ∞ a i x i 2 + b i x i + 1 \prod\limits_{k=0}^{∞}a_ix_i^2+b_ix_i+1 k=0∏∞​ai​xi2​+bi​xi​+1
考 虑 生 成 函 数 ： 考虑生成函数： 考虑生成函数：
= > ∑ k = 0 ∞ a i k 2 x k + b i x i x k + x k =>\sum\limits_{k=0}^{∞}a_ik^2x^k+b_ix_ix^k+x^k =>k=0∑∞​ai​k2xk+bi​xi​xk+xk = ∑ k = 0 ∞ a i k 2 x k + ∑ k = 0 ∞ b i x i x k + ∑ k = 0 ∞ x k , ( 三 项 分 别 当 作 A , B , C ) =\sum\limits_{k=0}^{∞}a_ik^2x^k+\sum\limits_{k=0}^{∞}b_ix_ix^k+\sum\limits_{k=0}^{∞}x^k,(三项分别当作A,B,C) =k=0∑∞​ai​k2xk+k=0∑∞​bi​xi​xk+k=0∑∞​xk,(三项分别当作A,B,C)
C = ∑ k = 0 ∞ x k = 1 1 − x C=\sum\limits_{k=0}^{∞}x^k=\frac{1}{1-x} C=k=0∑∞​xk=1−x1​

B = ∑ k = 0 ∞ b i x i x k B=\sum\limits_{k=0}^{∞}b_ix_ix^k B=k=0∑∞​bi​xi​xk
x B = ∑ k = 1 ∞ b i x i x k + 1 ， 两 式 联 立 解 得 ： xB=\sum\limits_{k=1}^{∞}b_ix_ix^{k+1}，两式联立解得： xB=k=1∑∞​bi​xi​xk+1，两式联立解得：
B = b i x ( 1 − x ) 2 B=\frac{b_ix}{(1-x)^2} B=(1−x)2bi​x​

A = ∑ k = 0 ∞ a i k 2 x k A=\sum\limits_{k=0}^{∞}a_ik^2x^k A=k=0∑∞​ai​k2xk
C = ∑ k = 0 ∞ x k = 1 1 − x C=\sum\limits_{k=0}^{∞}x^k=\frac{1}{1-x} C=k=0∑∞​xk=1−x1​
C ′ = ∑ k = 0 ∞ k x k − 1 = 1 ( 1 − x ) 2 C'=\sum\limits_{k=0}^{∞}kx^{k-1}=\frac{1}{(1-x)^2} C′=k=0∑∞​kxk−1=(1−x)21​
x C ′ = ∑ k = 0 ∞ k x k = x ( 1 − x ) 2 xC'=\sum\limits_{k=0}^{∞}kx^{k}=\frac{x}{(1-x)^2} xC′=k=0∑∞​kxk=(1−x)2x​
( x C ′ ) ′ = ∑ k = 0 ∞ k 2 x k − 1 = ( x + 1 ) ( 1 − x ) 3 (xC')'=\sum\limits_{k=0}^{∞}k^2x^{k-1}=\frac{(x+1)}{(1-x)^3} (xC′)′=k=0∑∞​k2xk−1=(1−x)3(x+1)​
x ( x C ′ ) ′ = ∑ k = 0 ∞ k 2 x k = x ( x + 1 ) ( 1 − x ) 3 x(xC')'=\sum\limits_{k=0}^{∞}k^2x^{k}=\frac{x(x+1)}{(1-x)^3} x(xC′)′=k=0∑∞​k2xk=(1−x)3x(x+1)​
A = a i ∗ x ( x C ′ ) ′ = a i x ( x + 1 ) ( 1 − x ) 3 A=a_i*x(xC')'=\frac{a_ix(x+1)}{(1-x)^3} A=ai​∗x(xC′)′=(1−x)3ai​x(x+1)​

因 此 ， 因此， 因此，

∑ k = 0 ∞ a i k 2 x k + b i x i x k + x k \sum\limits_{k=0}^{∞}a_ik^2x^k+b_ix_ix^k+x^k k=0∑∞​ai​k2xk+bi​xi​xk+xk = a i x ( x + 1 ) ( 1 − x ) 3 + b i x ( 1 − x ) 2 + 1 1 − x =\frac{a_ix(x+1)}{(1-x)^3}+\frac{b_ix}{(1-x)^2}+\frac{1}{1-x} =(1−x)3ai​x(x+1)​+(1−x)2bi​x​+1−x1​ = a i x ( x + 1 ) + ( 1 − x ) b i x + ( 1 − x ) 2 ( 1 − x ) 3 =\frac{a_ix(x+1)+(1-x)b_ix+(1-x)^2}{(1-x)^3} =(1−x)3ai​x(x+1)+(1−x)bi​x+(1−x)2​ = 1 + ( a i + b i − 2 ) x + ( a i − b i + 1 ) x 2 ( 1 − x ) 3 =\frac{1+(a_i+b_i-2)x+(a_i-b_i+1)x^2}{(1-x)^3} =(1−x)31+(ai​+bi​−2)x+(ai​−bi​+1)x2​

A n s w e r = ∏ i = 1 m 1 + ( a i + b i − 2 ) x + ( a i − b i + 1 ) x 2 ( 1 − x ) 3 Answer=\prod\limits_{i=1}^{m} \frac{1+(a_i+b_i-2)x+(a_i-b_i+1)x^2}{(1-x)^3} Answer=i=1∏m​(1−x)31+(ai​+bi​−2)x+(ai​−bi​+1)x2​ = ∏ i = 1 m 1 + ( a i + b i − 2 ) x + ( a i − b i + 1 ) x 2 ( 1 − x ) 3 m = \frac{\prod\limits_{i=1}^{m}1+(a_i+b_i-2)x+(a_i-b_i+1)x^2}{(1-x)^{3m}} =(1−x)3mi=1∏m​1+(ai​+bi​−2)x+(ai​−bi​+1)x2​

1 ( 1 − x ) n = ∑ i = 0 ∞ C n + i − 1 i x i \frac1{(1-x)^{n}}=\sum\limits_{i=0}^{∞}C_{n+i-1}^{i}{x^{i}} (1−x)n1​=i=0∑∞​Cn+i−1i​xi

A n s w e r = ∏ i = 1 m ( 1 + ( a i + b i − 2 ) x + ( a i − b i + 1 ) x 2 ) ∗ ∑ i = 0 ∞ C 3 m + i − 1 i x i Answer=\prod\limits_{i=1}^{m}(1+(a_i+b_i-2)x+(a_i-b_i+1)x^2)*\sum\limits_{i=0}^{∞}C_{3m+i-1}^{i}{x^{i}} Answer=i=1∏m​(1+(ai​+bi​−2)x+(ai​−bi​+1)x2)∗i=0∑∞​C3m+i−1i​xi

由于这个式子的复杂度会达到 O ( m n l o g n < 2 e 8 ) , m < 1 e 3 , n < 1 e 4 , l o g n < 20 O(mnlogn<2e8),m<1e3,n<1e4,logn<20 O(mnlogn<2e8),m<1e3,n<1e4,logn<20,因此需要运用分治。

code

/*SiberianSquirrel*//*CuteKiloFish*/
#include <bits/stdc++.h>
using namespace std;
#define gcd(a,b) __gcd(a,b)
#define Polynomial vector<ll>
#define Inv(x) quick_pow(x, mod - 2)
#define DEBUG(x, y) cout << x << ": " << y << '\n';
using ld = long double;
using ll = long long;
using ull = unsigned long long;
const ll mod = 998244353, mod_g = 3, img = 86583718;
//const ll mod = 1004535809, mod_g = 3;
const int N = int(1e5 + 10);
template<typename T> inline T read() {
    T x = 0, f = 1;
    char ch = getchar();
    while(ch < '0' || ch > '9') { if(ch == '-') f = -1; ch = getchar(); }
    while(ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
    return x * f;
}
template<typename T> inline T print(T x) {
    if(x < 0) { putchar('-'); x =- x; }
    if(x > 9) print(x / 10);
    putchar(x % 10 + '0');
}

void print(Polynomial &a, int len){
    for(int i = 0; i < len; ++ i)
        cout << a[i] << ' ';
    cout << '\n';
}
void exgcd(int a,int b,int &x,int &y){
    if(!b) {
        x = 1; y = 0;
        return;
    }
    exgcd(b, a % b, y, x);
    y -= x * (a / b);
}
int quick_pow(int ans, int p, int res = 1) {
    for(; p; p >>= 1, ans = 1ll * ans * ans % mod)
        if(p & 1) res = 1ll * res * ans % mod;
    return res % mod;
}

Polynomial R;
//二进制向上取整，为方便NTT变换准备。
inline int Binary_Rounding(const int &n) {
    int len = 1; while(len < n) len <<= 1;
    return len;
}
//预处理R数组，准备变换，在每次NTT之前理论都要调用此函数。
inline int Prepare_Transformation(int n){
    int L = 0, len;
    for(len = 1; len < n; len <<= 1) L++;
    R.clear(); R.resize(len);
    for(int i = 0; i < len; ++ i)
        R[i] = (R[i>>1]>>1)|((i&1)<<(L-1));
    return len;
}
void NTT(Polynomial &a, int f){
    int n = a.size();
    for(int i = 0; i < n; ++ i)
        if(i < R[i])swap(a[i], a[R[i]]);
    for(int i = 1; i < n; i <<= 1)
        for(int j = 0, gn = quick_pow(mod_g,(mod - 1) / (i<<1)); j < n; j += (i<<1))
            for(int k = 0, g = 1, x, y; k < i; ++ k, g = 1ll * g * gn % mod)
                x = a[j + k], y = 1ll * g * a[i + j + k] % mod,
                a[j + k] = (x + y) % mod, a[i + j + k] = (x - y + mod) % mod;
    if(f == -1){
        reverse(a.begin() + 1, a.end());
        int inv = Inv(n);
        for(int i = 0; i < n; ++ i) a[i] = 1ll * a[i] * inv % mod;
    }
}

inline Polynomial operator +(const Polynomial &a, const int &b){
    int sizea = a.size(); Polynomial ret = a; ret.resize(sizea);
    for(int i = 0; i < sizea; ++ i)ret[i] = (1ll * a[i] + b + mod) % mod;
    return ret;
}
inline Polynomial operator -(const Polynomial &a, const int &b){
    int sizea = a.size(); Polynomial ret = a; ret.resize(sizea);
    for(int i = 0; i < sizea; ++ i)ret[i] = (1ll * a[i] - b + mod) % mod;
    return ret;
}
inline Polynomial operator *(const Polynomial &a, const int &b){
    int sizea = a.size(); Polynomial ret = a; ret.resize(sizea);
    for(int i = 0; i < sizea; ++ i) ret[i] = (1ll * a[i] * b % mod + mod) % mod;
    return ret;
}
inline Polynomial operator +(const Polynomial &a, const Polynomial &b){
    int sizea = a.size(), sizeb = b.size(), size = max(sizea, sizeb);
    Polynomial ret = a; ret.resize(size);
    for(int i = 0; i < sizeb; ++ i) ret[i] = (1ll * ret[i] + b[i]) % mod;
    return ret;
}
inline Polynomial operator -(const Polynomial &a, const Polynomial &b){
    int sizea = a.size(), sizeb = b.size(), size = max(sizea, sizeb);
    Polynomial ret = a; ret.resize(size);
    for(int i = 0; i < sizeb; ++ i) ret[i] = (1ll * ret[i] - b[i] + mod) % mod;
    return ret;
}
inline Polynomial Inverse(const Polynomial &a){
    Polynomial ret, inv_a;
    ret.resize(1);
    ret[0] = Inv(a[0]); int ed = a.size();
    for(int len = 2; len <= ed; len <<= 1){
        int n = Prepare_Transformation(len << 1);
        inv_a = a; inv_a.resize(n); ret.resize(n);
        for(int i = len; i < n; ++ i) inv_a[i] = 0;
        NTT(inv_a, 1); NTT(ret, 1);
        for(int i = 0; i < n; ++ i)
            ret[i] = 1ll * (2ll - 1ll * inv_a[i] * ret[i] % mod + mod) % mod * ret[i] % mod;
        NTT(ret, -1);
        for(int i = len; i < n; ++ i) ret[i] = 0;
    }
    ret.resize(ed);
    return ret;
}
inline Polynomial operator *(const Polynomial &a, const Polynomial &b){
    Polynomial lsa = a, lsb = b, ret;
    int n = lsa.size(), m = lsb.size();
    n = Prepare_Transformation(n + m);
    lsa.resize(n); lsb.resize(n); ret.resize(n);
    NTT(lsa,1); NTT(lsb,1);
    for(int i = 0; i < n; ++ i) ret[i] = 1ll * lsa[i] * lsb[i] % mod;
    NTT(ret,-1);
    return ret;
}
inline Polynomial operator /(const Polynomial &a, const Polynomial &b){
    Polynomial ret = a, ls = b;
    reverse(ret.begin(), ret.end());
    reverse(ls.begin(), ls.end());
    ls.resize(Binary_Rounding(a.size() + b.size()));
    ls = Inverse(ls);
    ls.resize(a.size() + b.size());
    ret = ret * ls; ret.resize(a.size() - b.size() + 1);
    reverse(ret.begin(), ret.end());
    return ret;
}
inline Polynomial operator %(const Polynomial &a, const Polynomial &b){
    Polynomial ret = a / b;
    ret = ret * b; ret.resize(a.size() + b.size());
    ret = a - ret; ret.resize(a.size() + b.size());
    return ret;
}
inline Polynomial Derivation(const Polynomial &a){
    int size = a.size(); Polynomial ret; ret.resize(size);
    for(int i = 1; i < size; ++ i) ret[i - 1] = 1ll * i * a[i] % mod;
    ret[size - 1] = 0;
    return ret;
}
inline Polynomial Integral(const Polynomial &a){
    int size = a.size(); Polynomial ret; ret.resize(size);
    for(int i = 1; i < size; ++ i) ret[i] = 1ll * Inv(i) * a[i - 1] % mod;
    ret[0] = 0;
    return ret;
}
inline Polynomial Composition_Inverse(const Polynomial &a){
    int n = a.size();
    Polynomial ret, Cinv = a, Pow;
    Cinv.resize(n); ret.resize(n); Pow.resize(n); Pow[0] = 1;
    for(int i = 0; i < n - 1; ++ i) Cinv[i] = Cinv[i + 1]; Cinv[n - 1] = 0;
    Cinv = Inverse(Cinv);
    for(int i = 1; i < n; ++ i){
        Pow = Pow * Cinv; Pow.resize(n);
        ret[i] = 1ll * Pow[i - 1] * Inv(i) % mod;
    }
    return ret;
}
inline Polynomial Logarithmic(const Polynomial &a){
    Polynomial ln_a = Derivation(a) * Inverse(a);
    ln_a.resize(a.size());
    return Integral(ln_a);
}
inline Polynomial Exponential(const Polynomial &a, int Constant = 1){
    Polynomial ret, D; int ed = a.size();
    ret.resize(1); ret[0] = Constant;
    for(int len = 2; len <= ed; len <<= 1){
        D = Logarithmic(ret); D.resize(len);
        D[0] = (1ll * a[0] + 1ll - D[0] + mod) % mod;
        for(int i = 1; i < len; ++i) D[i] = (1ll * a[i] - D[i] + mod) % mod;
        int n = Prepare_Transformation(len<<1);
        ret.resize(n); D.resize(n);
        NTT(ret, 1); NTT(D,1);
        for(int i = 0; i < n; ++ i) ret[i] = 1ll * ret[i] * D[i] % mod;
        NTT(ret, -1);
        for(int i = len; i < (len<<1); ++ i) ret[i] = D[i] = 0;
    }
    ret.resize(ed);
    return ret;
}

ll fac[int(6e5 + 10)] = {1}, ifac[int(6e5 + 10)] = {1};
ll C(int n, int m) {
    if(m == 0 || n == m) return 1;
    if(n < m) return 0;
    return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}

//Polynomial ans(3);
Polynomial a(1010), b(1010);

Polynomial DAC_NTT(int l, int r) {
    if (l == r) {
        Polynomial res;
        ll A = 1;
        ll B = (a[l] + b[l] - 2) % mod; while(B < 0) B += mod;
        ll C = (a[l] - b[l] + 1) % mod; while(C < 0) C += mod;
        res.push_back(A); res.push_back(B); res.push_back(C);
        return res;
    }
    int mid = l + r >> 1;
    return DAC_NTT(l, mid) * DAC_NTT(mid + 1, r);
}

inline void solve() {
    for(int i = 1; i <= int(6e5); ++ i) fac[i] = 1ll * fac[i - 1] * i % mod, ifac[i] = Inv(fac[i]);
    int m; cin >> m;
    Polynomial res(50010);
    for(int i = 0; i <= 50000; ++ i) {
        res[i] = C(3 * m + i - 1, i);
    }
//     Polynomial ans;
    for(int i = 1; i <= m; ++ i) {
        cin >> a[i] >> b[i];
//         ll A = 1;
//         ll B = (a[i] + b[i] - 2) % mod; while(B < 0) B += mod;
//         ll C = (a[i] - b[i] + 1) % mod; while(C < 0) C += mod;
//         if(i == 1) {
//             ans.push_back(A), ans.push_back(B), ans.push_back(C);
//         } else {
//             Polynomial temp;
//             temp.push_back(A), temp.push_back(B), temp.push_back(C);
//             ans = ans * temp;
//         }
    }
    Polynomial ans = DAC_NTT(1, m);
    ans = ans * res;
    int q; cin >> q; while(q --) {
        int n; cin >> n;
        cout << ans[n] << '\n';
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
//    freopen("output", "w", stdout);
    signed test_index_for_debug = 1;
    char acm_local_for_debug = 0;
    do {
        if (acm_local_for_debug == '$') exit(0);
        if (test_index_for_debug > 20)
            throw runtime_error("Check the stdin!!!");
        auto start_clock_for_debug = clock();
        solve();
        auto end_clock_for_debug = clock();
        cout << "Test " << test_index_for_debug << " successful" << endl;
        cerr << "Test " << test_index_for_debug++ << " Run Time: "
             << double(end_clock_for_debug - start_clock_for_debug) / CLOCKS_PER_SEC << "s" << endl;
        cout << "--------------------------------------------------" << endl;
    } while (cin >> acm_local_for_debug && cin.putback(acm_local_for_debug));
#else
    solve();
#endif
    return 0;
}
西伯利亚松鼠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
NTT.rar_NTT_NTT c++_NTT%20c%2B%2B_nttc++_快速数论变换
09-20
用c++实现的快速数论变换(NTT)，利用原根性质，实现和FFT的功能，但是效率比FFT高。
2022“杭电杯”中国大学生算法设计超级联赛（5）Count Set（分治ntt，生成函数，组合数学）
m0_61735576的博客
08-19 272
选一个点，旁边的两个点就不能选，就转化为一个从n-3个点中选m-1个不相邻的点，转化为链式。得到这个答案就可以先算出每个环的生成函数，然后分治合并，取最后答案的第k项就是答案。题目为给定我们一个n的排列为p，让我们从1-n的序列中选出长度为k的子序列。不选一个点，那么转化为一个从n-1个点选m个不相邻，转化为链式。我们知道从n个点选m个不相邻的点的链式不相邻问题的答案是。问题就转化为从数个环上选出k个点，使得所有点都不相邻。表示从长度为n的环中选i个点的选法。我们计算每一个环的生成函数，使得。
BZOJ 3451 点分治 + NTT
neweryyy的博客
04-07 227
题意 传送门 BZOJ 3451 Tyvj1953 Normal 题解 若 vvv 取为分治中心时，uuu 与 vvv 连通，则 uuu 贡献为 111。u,vu,vu,v 再 vvv 取为分治中心时连通的条件为 u,vu,vu,v 路径上任意节点都未被选取为分支中心，不属于路径上的节点对于这个概率没有影响，则概率等价于 u,vu,vu,v 路径上的点中，vvv 被首先选取的概率，其等于 1/(dist(u,v)+1)1/\Big(dist(u,v) + 1\Big)1/(dist(u,v)+1) 总贡献
1218E - Product Tuples（生成函数 分治NTT）
jkchen's Haven
10-02 487
original link - https://codeforces.com/problemset/problem/1218/E 题意： 101010次查询，每次构造出长度nnn的aaa数组，CnkC_n^kCnk​个kkk元组，求∑i=1Cnk∏j=1kapj\sum_{i=1}^{C_n^k}\prod_{j=1}^k a_{p_j}∑i=1Cnk​​∏j=1k​apj​​，也就是任意选择kk...
BZOJ 3456 城市规划 生成函数 NTT
Chlience的博客
08-22 260
题意 求nnn个有标号点的无向联通图个数 Solution 发现直接求解很复杂，将其用别的函数表示出来 设f(x)f(x)f(x)为包含111号节点的节点数为xxx 无向连通图 个数，g(x)g(x)g(x)为节点数为xxx的 无向图 个数 这两个函数有以下关系： g(n)=∑i=1nCi−1n−1f(i)g(n−i)g(n)=∑i=1nCn−1i−1f(i)g(n−i)g(n...
【HDU6426】【LOJ6538】Alkane（生成函数）（分治NTT）（Burnside）
zxyoi_dreamer的博客（不定期诈尸）
07-28 679
比较毒瘤的群论推导题
david harvey NTT
11-18
We show how to improve the efficiency of the computation of fast Fourier transforms over F_p where p is a word-sized prime. Our main technique is optimisation of the basic arithmetic, in effect ...
任意模数NTT的代码
08-22
这是任意模数NTT的代码，非常地实用。我的代码比较好理解，希望能够和大家分享。
日本NTT网络中SDN技术应用实践
01-19
讨论了SDN/NFV技术在通信领域的应用情况，重点分析了日本运营商NTT在此领域的探索和最新进展，简要对比了海外市场与国内市场商业应用的情况，初步给出了国内市场发展SDN/NFV的基本建议。
NTTDATA订制就业培养对日软件外包人才需求信息.doc
11-21
NTTDATA 订制就业培养对日软件外包人才需求信息 本文档主要介绍了 NTTDATA 订制就业培养对日软件外包人才需求信息，旨在满足重庆 NTTDATA 对日软件外包人才需求的需求。该培养项目旨在培养日本企业模式规范化治理的...
HDU 6270 Marriage （2017 CCPC 杭州赛区 G题，生成函数 + 容斥 + 分治NTT）
weixin_30916125的博客
06-20 257
题目链接 2017 CCPC Hangzhou Problem G 题意描述很清晰。 考虑每个家庭有且仅有$k$对近亲的方案数： $C(a, k) * C(b, k) * k!$ 那么如果在第$1$个家庭里面选出$k_{1}$对近亲，在第$2$个家庭里面选出$k_{2}$对近亲......在第$n$个家庭里面选出$k_{n}$对近亲， 剩下那些人自由组合的话，那么最后这种方案至少会有$...
洛谷 P2000 拯救世界 —— 生成函数+NTT
天翼之城的博客
01-15 336
This way 题意： 有n个石头，每个石头都可以变成五行当中的一种，问你有多少种变换方法满足下列要求 题解： 生成函数在特殊情况下可以转换成组合数公式，推荐一篇文章：This way 第一个条件：必须是6的倍数，那么就是11−x6\frac{1}{1-x^6}1−x61​ 第二个条件就是1−x101−x\frac{1-x^{10}}{1-x}1−x1−x10​ 其实每个条件都是独立的，那么满足所有条件就相当于将所有条件乘起来：11−x5=Cn+44\frac{1}{1-x^5}=C_{n+4}^41
HDU 5322 Hope （分治 + NTT）
Lee_w_j__的博客
08-23 278
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5322 题目大意：对于1~n的全排列中的任意一个排列，对于在排列中的任意一个 i，如果存在一个离 i 最近的 j 满足 i &lt; j 且 A[i] &lt; A[j]，就在 i 和 j 之间建一条无向边。照此规矩建完边之后，如果联通图内的点数为P，那么这一个联通图的贡献就是P*P，种排列的贡献就为...
hdu 5322 Hope（分治+NTT）
ok_again的专栏
08-05 1339
分治+NTT。思路是多校题解上的思路，我只是敲了一遍代码。 下面图片引用自：http://blog.sina.com.cn/s/blog_15139f1a10102vo6q.html 由于给定MOD是一个质数，并且998244353=119*2^23 + 1，所以可以用NTT直接代替FFT。 //#pragma comment(linker, "/STACK:1024000000,1
[CTS2019]珍珠 NTT 生成函数
maxtir的博客
06-17 325
[CTS2019]珍珠 题目传送门： luogu 分析 考虑每种颜色有几个。假设已经求出了每种颜色的个数为d1,d2⋯dDd_1,d_2\cdots d_Dd1​,d2​⋯dD​ 方案数就是n!d1!d2!⋯dD!\frac{n!}{d_1!d_2!\cdots d_D!}d1​!d2​!⋯dD​!n!​ 考虑这个方案合法的要求。 ∑di(mod&ThinSpace;&ThinSp...
【洛谷5月月赛】玩游戏（NTT，生成函数）
小蒟蒻yyb的博客
06-13 260
题面 Luogu 题解 看一下要求的是什么东西 (ax+by)i(ax+by)i(a_x+b_y)^i的期望。期望显然是所有答案和的平均数。 所以求出所有的答案就在乘一个逆元就好了。 现在考虑怎么算上面那个东西。 对于单个的计算，我们可以用二项式定理直接展开 得到 ∑(a+b)k=∑∑i=0kCikaibk−i=∑i=0kCik(∑ai)(∑bk−i)=∑i=0kk!i!(k...
【洛谷P4705】—玩游戏（生成函数+NTT）
Stargazer的博客
08-10 197
传送门 VanVanVan游戏？ 显然我们要求的是 Ans=t!∑k=1t∑i=1naikk!∑j=1mbjt−k(t−k)!Ans=t!\sum_{k=1}^{t}\sum_{i=1}^{n}\frac{a_i^k}{k!}\sum_{j=1}^{m}\frac{b_j^{t-k}}{(t-k)!}Ans=t!∑k=1t​∑i=1n​k!aik​​∑j=1m​(t−k)!bjt−k​​ 考虑求...
【LOJ2541】猎人杀（PKUWC2018）-容斥+级数+分治NTT
Maxwei_wzj的OI世界
06-16 1386
测试地址：猎人杀 做法：本题需要用到容斥+级数+分治NTT。 要求111号最后一个被射杀，其实就是要求所有人都不能在111号后被射杀。这种要求全部条件满足求方案数/概率的情况，就要考虑容斥，即枚举一个集合SSS，计算强制这SSS个人在111号后被射杀的概率p(S)p(S)p(S)，那么答案就等于： ans=∑S(−1)|S|p(S)ans=∑S(−1)|S|p(S)ans=\sum_S(-1...
CF1096G Lucky Tickets [生成函数+NTT]
FSYo 的博客
07-11 340
传送门 我们如果能求出 n/2 个数能组合出的某个数的方案数 v, 那么v^2 就是这个数的贡献 发现可以用生成函数, 类似下面这样构造 组合成9的方案数就是2, 然后NTT就可以了 #include<bits/stdc++.h> #define N 4000050 using namespace std; int n, k, up, bit, rev[N]; typed...
FFT/NTT高精度
最新发布
08-22
您好！对于使用FFT（快速傅里叶变换）或NTT（快速数论变换）来实现高精度计算，可以采以下步骤： 1. 将数字表示为多项式形式：将需要进行高精度计算的数字转换为多项式的系数形式。例如，将一个整数表示为多项式的系数。 2. 补零：为了进行FFT或NTT，需要将系数数组的长度扩展为2的幂次方。如果系数数组长度不是2的幂次方，可以在末尾添加零，使其长度满足要求。 3. 进行FFT或NTT：使用选择的变换算法（FFT或NTT）对系数数组进行变换。这将把多项式从系数域转换到点值域。 4. 点值运算：在点值域中，对应位置的点值可以通过乘法或加法来进行运算。例如，如果要计算乘法，则可以对应位置相乘；如果要计算加法，则对应位置相加。 5. 逆变换：对变换后的结果进行逆变换，将其从点值域转回系数域。 6. 去除高位零：在得到逆变换结果后，需要去除多余的高位零，以获得最终的高精度计算结果。 需要注意的是，FFT和NTT是用于加速多项式乘法的算法，通过将乘法复杂度从O(n^2)降低到O(nlogn)，其中n是多项式的长度。因此，它们通常与其他算法一起使用，如Karatsuba乘法或Schönhage-Strassen乘法，以实现高精度计算。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值