快速傅里叶变换

于 2021-09-06 22:31:14 发布
阅读量1.4k 收藏 14
点赞数 11
分类专栏： 数论 模板 文章标签： 线性代数 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45911397/article/details/120146552
版权

用途在 O ( n l o g n ) O(nlog_n) O(nlogn​)复杂度内解决多项式乘法 比 O ( N 2 ) O(N^2) O(N2)要优

A ( x ) = a 0 + a 1 x + . . . + a n x n A(x)=a_0+a_1x+...+a_nx^n A(x)=a0​+a1​x+...+an​xn

性质一：可以用n+1个点，表示一个n次多项式

证明用高斯消元，范德蒙行列式满秩唯一解。

点表示法：

如果多项式乘积为： C ( x ) = A ( x ) B ( x ) C(x)=A(x)B(x) C(x)=A(x)B(x)

那么：如果A(x)是n次的，B(x)是m次的，那么我们能用n+m+1个点表示C(x)。

x 1 , x 2 , x 3 . . . . . x n + m + 1 x_1,x_2,x_3.....x_{n+m+1} x1​,x2​,x3​.....xn+m+1​

A对应的点为： ( x 1 , A ( x 1 ) ) , ( x 2 , A ( x 2 ) . . . . ( x n + m + 1 , A ( x n + m + 1 ) ) (x_1,A(x_1)),(x_2,A(x_2)....(x_{n+m+1},A(x_{n+m+1})) (x1​,A(x1​)),(x2​,A(x2​)....(xn+m+1​,A(xn+m+1​))

B对应的点为： ( x 1 , B ( x 1 ) ) , ( x 2 , B ( x 2 ) . . . . ( x n + m + 1 , B ( x n + m + 1 ) ) (x_1,B(x_1)),(x_2,B(x_2)....(x_{n+m+1},B(x_{n+m+1})) (x1​,B(x1​)),(x2​,B(x2​)....(xn+m+1​,B(xn+m+1​))

我们知道C(x)=A(x)B(x)

那么C对应的点为： ( x 1 , A ( x 1 ) B ( x 1 ) ) , ( x 2 , A ( x 2 ) B ( x 2 ) . . . . ( x n + m + 1 , A ( x n + m + 1 ) B ( x n + m + 1 ) ) (x_1,A(x_1)B(x_1)),(x_2,A(x_2)B(x_2)....(x_{n+m+1},A(x_{n+m+1})B(x_{n+m+1})) (x1​,A(x1​)B(x1​)),(x2​,A(x2​)B(x2​)....(xn+m+1​,A(xn+m+1​)B(xn+m+1​))

所以我们可以通过O(n+m)表示出来C(x);

所以我们希望从系数表示法转化成点表示法，在从点表示法转化成系数表示法。

复数

欧拉公式证明：

证明过程参考繁凡博客吧。
https://www.wolai.com/naS2MSmNf2imHpmYtEpUtF#bedxV3DwQ7wfDDThBQg78S

在这里插入图片描述

递归版：未运行出来：

///FFT递归版
#include <bits/stdc++.h>
using namespace std;

const double pi = acos(-1);
const int N = 300;
struct Complex
{
    double x, y;
    Complex(double x = 0, double y = 0): x(x), y(y) {}
} A[N], B[N];
Complex operator * (Complex J, Complex Q)
{
    //模长相乘，幅度相加
    return Complex(J.x * Q.x - J.y * Q.y, J.x * Q.y + J.y * Q.x);
}
Complex operator - (Complex J, Complex Q)
{
    return Complex(J.x - Q.x, J.y - Q.y);
}
Complex operator + (Complex J, Complex Q)
{
    return Complex(J.x + Q.x, J.y + Q.y);
}

void FFT(int limit, Complex *a, int type)
{
    if(limit == 1) return ;//常数项
    Complex a1[limit / 2], a2[limit / 2]; //分成两端，左右两端平分
    for(int i = 0; i <= limit; i += 2) //偶数项,奇数项
    {
        a1[i / 2] = a[i];
        a2[i / 2] = a[i + 1];
    }
    FFT(limit / 2, a1, type);
    FFT(limit / 2, a2, type);
    Complex tmp = Complex(cos(2.0 * pi / limit), type * sin(2.0 * pi / limit)), w = Complex(1, 0);
    ///tmp表示单位根，w表示幂。
    for(int i = 0; i < (limit /2); i++, w = w * tmp)
    {
        a[i] = a1[i] + w * a2[i]; //左加
        a[i + limit / 2] = a1[i] - w * a2[i]; //右减
    }
}
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 0; i <= n; i++)scanf("%lf", &A[i].x);
    for(int i = 0; i <= m; i++)scanf("%lf", &B[i].x);

    int limit = 1;
    while(limit <= n + m) limit *= 2; //2的整数次幂

    FFT(limit, A, 1);
    FFT(limit, B, 1);
    //后面的1表示要进行的变换是什么类型
    // 1表示从系数变为点值
    //-1表示从点值变为系数
    //这就与推导过程中的 w指数部分正负有关。
    for(int i = 0; i <= limit; i++)
    {
        A[i] = A[i] * B[i];
    }
    FFT(limit, A, -1);

    for(int i = 0;i <= n + m; i++)
    {
        printf("%d ", (int)(A[i].x / limit + 0.5)); ///对其四舍五入+0.5
    }

    return 0;
}

迭代版

蝴蝶变换

///迭代版
#include <bits/stdc++.h>
using namespace std;

const int N = 5e6 + 7;
const double PI = acos(-1);

int n, m;
int limit = 1;
int res, ans[N];
int l;
int r[N];

struct Complex
{
    double x, y;
    Complex (double x = 0, double y = 0) : x(x), y(y) {}
} a[N], b[N];

Complex operator * (Complex J, Complex Q)
{
    //模长相乘，幅度相加
    return Complex(J.x * Q.x - J.y * Q.y, J.x * Q.y + J.y * Q.x);
}
Complex operator + (Complex J, Complex Q)
{
    return Complex(J.x + Q.x, J.y + Q.y);
}
Complex operator - (Complex J, Complex Q)
{
    return Complex(J.x - Q.x, J.y - Q.y);
}
void FFT(Complex *A, int type)
{
    for(int i = 0; i < limit; i++)
    {
        if(i < r[i]) swap(A[i], A[r[i]]); ///保证不在换过去
    }
    ///从底层开始合并：
    for(int mid = 1; mid < limit; mid = mid * 2)
    {
        ///待合并区间长度的一半，最开始是长度为1的合并，类似倍增的思想
        Complex wn(cos(PI / mid), type * sin(PI / mid)); //单位根

        for(int len = mid *2, pos = 0; pos < limit; pos += len)
        {
            ///len是区间的长度，pos是当前的位置
            Complex w(1, 0);
            for(int k = 0; k < mid; k++, w = w * wn)
            {
                ///只扫左半部分，蝴蝶变换得到有半部分。
                Complex x = A[pos + k]; //左半部分
                Complex y = w * A[pos + mid + k]; //右半部分
                A[pos + k] = x + y;//左加
                A[pos + mid + k] = x - y;///右减
            }
        }
    }

    if(type == 1) return ;
    for(int i = 0; i <= limit; i++)
    {
        A[i].x = A[i].x / limit;
        A[i].y = A[i].y / limit;///这个版本没用，加不加没影响，优化的版本必须要加
        ///除以我们推出的N。
    }
}

int main()
{
    cin >> n >> m;

    for(int i = 0; i <= n; i++) scanf("%lf", &a[i].x);
    for(int j = 0; j <= m; j++) scanf("%lf", &b[j].x);

    while(limit <= n + m) limit <<= 1, l++;///求出位数l，和2的整数次幂
    
    for(int i = 0; i < limit; i++)
    {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));///蝴蝶变换。
    }
    FFT(a, 1);
    FFT(b, 1);

    for(int i = 0; i <= limit; ++i)
    {
        a[i] = a[i] * b[i];
    }

    FFT(a, -1);

    for(int i = 0; i <= m + n; i++)
    {
        printf("%d ", int(a[i].x + 0.5));
    }

    return 0;
}

优化：三步变两步：

设a和b是实多项式， F = a + b i F=a+bi F=a+bi则 F 2 = a 2 − b 2 + 2 a b i F^2=a^2-b^2+2abi F2=a2−b2+2abi ，注意我们要求的是F虚部的一半，这样我们通过两次FFT就可以求出结果了，

所以我们可以把 b ( x ) b(x) b(x)放到a(x)的虚部，求出 a ( x ) 2 a(x)^2 a(x)2然后取出a(x)虚部除以2就是答案。

///优化版
#include <bits/stdc++.h>
using namespace std;

const int N = 5e6 + 7;
const double PI = acos(-1);

int n, m;
int limit = 1;
int res, ans[N];
int l;
int r[N];

struct Complex
{
    double x, y;
    Complex (double x = 0, double y = 0) : x(x), y(y) {}
} a[N], b[N];

Complex operator * (Complex J, Complex Q)
{
    //模长相乘，幅度相加
    return Complex(J.x * Q.x - J.y * Q.y, J.x * Q.y + J.y * Q.x);
}
Complex operator + (Complex J, Complex Q)
{
    return Complex(J.x + Q.x, J.y + Q.y);
}
Complex operator - (Complex J, Complex Q)
{
    return Complex(J.x - Q.x, J.y - Q.y);
}
void FFT(Complex *A, int type)
{
    for(int i = 0; i < limit; i++)
    {
        if(i < r[i]) swap(A[i], A[r[i]]); ///保证不在换过去
    }
    ///从底层开始合并：
    for(int mid = 1; mid < limit; mid = mid * 2)
    {
        ///待合并区间长度的一半，最开始是长度为1的合并，类似倍增的思想
        Complex wn(cos(PI / mid), type * sin(PI / mid)); //单位根

        for(int len = mid *2, pos = 0; pos < limit; pos += len)
        {
            ///len是区间的长度，pos是当前的位置
            Complex w(1, 0);
            for(int k = 0; k < mid; k++, w = w * wn)
            {
                ///只扫左半部分，蝴蝶变换得到有半部分。
                Complex x = A[pos + k]; //左半部分
                Complex y = w * A[pos + mid + k]; //有半部分
                A[pos + k] = x + y;
                A[pos + mid + k] = x - y;
            }
        }
    }

    if(type == 1) return ;
    for(int i = 0; i <= limit; i++)
    {
        A[i].x = A[i].x / limit;
        A[i].y = A[i].y / limit;
        ///除以我们推出的N。
    }
}

int main()
{
    cin >> n >> m;

    for(int i = 0; i <= n; i++) scanf("%lf", &a[i].x);
    for(int j = 0; j <= m; j++) scanf("%lf", &a[j].y);

    while(limit <= n + m) limit <<= 1, l++;


    for(int i = 0; i < limit; i++)
    {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
    }
    FFT(a, 1);
    ///FFT(b, 1);

    for(int i = 0; i <= limit; ++i)
    {
        a[i] = a[i] * a[i];
    }

    FFT(a, -1);

    for(int i = 0; i <= m + n; i++)
    {
        printf("%d ", int(a[i].y/2 + 0.5));
    }

    return 0;
}

例题：P1919 【模板】FFT快速傅里叶变换

///优化版
#include <bits/stdc++.h>
using namespace std;

const int N = 5e6 + 7;
const double PI = acos(-1);

int n, m;
int limit = 1;
int res, ans[N];
int l;
int r[N];

struct Complex
{
    double x, y;
    Complex (double x = 0, double y = 0) : x(x), y(y) {}
} a[N], b[N];

Complex operator * (Complex J, Complex Q)
{
    //模长相乘，幅度相加
    return Complex(J.x * Q.x - J.y * Q.y, J.x * Q.y + J.y * Q.x);
}
Complex operator + (Complex J, Complex Q)
{
    return Complex(J.x + Q.x, J.y + Q.y);
}
Complex operator - (Complex J, Complex Q)
{
    return Complex(J.x - Q.x, J.y - Q.y);
}
void FFT(Complex *A, int type)
{
    for(int i = 0; i < limit; i++)
    {
        if(i < r[i]) swap(A[i], A[r[i]]); ///保证不在换过去
    }
    ///从底层开始合并：
    for(int mid = 1; mid < limit; mid = mid * 2)
    {
        ///待合并区间长度的一半，最开始是长度为1的合并，类似倍增的思想
        Complex wn(cos(PI / mid), type * sin(PI / mid)); //单位根

        for(int len = mid * 2, pos = 0; pos < limit; pos += len)
        {
            ///len是区间的长度，pos是当前的位置
            Complex w(1, 0);
            for(int k = 0; k < mid; k++, w = w * wn)
            {
                ///只扫左半部分，蝴蝶变换得到有半部分。
                Complex x = A[pos + k]; //左半部分
                Complex y = w * A[pos + mid + k]; //有半部分
                A[pos + k] = x + y;
                A[pos + mid + k] = x - y;
            }
        }
    }

    if(type == 1) return ;
    for(int i = 0; i <= limit; i++)
    {
        ans[i] += (int)(A[i].y / limit/2 + 0.5);
        if(ans[i] >= 10) ///考虑进位问题。
        {
            ans[i + 1] = ans[i] / 10;
            ans[i] %= 10;
            limit += (i == limit); ///进位
        }
        ///除以我们推出的N。
    }
}
string str, s;
int main()
{
    cin >> str >> s;
    n = str.size();
    m = s.size();
    int cnt, tot;
    cnt = tot = 0;
    for(int i = n - 1; i >= 0; i--) a[cnt++].x = str[i] - '0';
    for(int i = m - 1; i >= 0; i--) a[tot++].y = s[i] - '0';

    while(limit < n + m) limit <<= 1, l++;

    for(int i = 0; i <= limit; i++)
    {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
    }
    FFT(a, 1);
    ///FFT(b, 1);

    for(int i = 0; i <= limit; ++i)
    {
        a[i] = a[i] * a[i];
    }

    FFT(a, -1);

    while(!ans[limit] && limit >= 1) limit--; ///去除前导0

    limit++;
    while(--limit >= 0)
    {
        cout << ans[limit];
    }

    return 0;
}

正常版。

//正常的
#include <bits/stdc++.h>
using namespace std;

const int N = 5e6 + 7;
const double PI = acos(-1);

int n, m;
int limit = 1;
int res, ans[N];
int l;
int r[N];

struct Complex
{
    double x, y;
    Complex (double x = 0, double y = 0) : x(x), y(y) {}
} a[N], b[N];

Complex operator * (Complex J, Complex Q)
{
    //模长相乘，幅度相加
    return Complex(J.x * Q.x - J.y * Q.y, J.x * Q.y + J.y * Q.x);
}
Complex operator + (Complex J, Complex Q)
{
    return Complex(J.x + Q.x, J.y + Q.y);
}
Complex operator - (Complex J, Complex Q)
{
    return Complex(J.x - Q.x, J.y - Q.y);
}
void FFT(Complex *A, int type)
{
    for(int i = 0; i < limit; i++)
    {
        if(i < r[i]) swap(A[i], A[r[i]]); ///保证不在换过去
    }
    ///从底层开始合并：
    for(int mid = 1; mid < limit; mid = mid * 2)
    {
        ///待合并区间长度的一半，最开始是长度为1的合并，类似倍增的思想
        Complex wn(cos(PI / mid), type * sin(PI / mid)); //单位根

        for(int len = mid * 2, pos = 0; pos < limit; pos += len)
        {
            ///len是区间的长度，pos是当前的位置
            Complex w(1, 0);
            for(int k = 0; k < mid; k++, w = w * wn)
            {
                ///只扫左半部分，蝴蝶变换得到有半部分。
                Complex x = A[pos + k]; //左半部分
                Complex y = w * A[pos + mid + k]; //有半部分
                A[pos + k] = x + y;
                A[pos + mid + k] = x - y;
            }
        }
    }

    if(type == 1) return ;
    for(int i = 0; i <= limit; i++)
    {
        ans[i] += (int)(A[i].x / limit + 0.5);
        if(ans[i] >= 10) ///考虑进位问题。
        {
            ans[i + 1] = ans[i] / 10;
            ans[i] %= 10;
            limit += (i == limit); ///进位
        }
        ///除以我们推出的N。
    }
}
string str, s;
int main()
{
    cin >> str >> s;
    n = str.size();
    m = s.size();
    int cnt, tot;
    cnt = tot = 0;
    for(int i = n - 1; i >= 0; i--) a[cnt++].x = str[i] - '0';
    for(int i = m - 1; i >= 0; i--) b[tot++].x = s[i] - '0';

    while(limit < n + m) limit <<= 1, l++;

    for(int i = 0; i <= limit; i++)
    {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
    }
    FFT(a, 1);
    FFT(b, 1);

    for(int i = 0; i <= limit; ++i)
    {
        a[i] = a[i] * b[i];
    }

    FFT(a, -1);

    while(!ans[limit] && limit >= 1) limit--; ///去除前导0

    limit++;
        while(--limit>=0)
        {
            cout << ans[limit];
        }
    
    return 0;
}

P3338 [ZJOI2014]力

先放上，防止自己咕咕咕

题意：

n个数

q 1 , q 2 , . . . q n q_1,q_2,...q_n q1​,q2​,...qn​定义

F j = ∑ i = 1 j − 1 q i × q j ( i − j ) 2 − ∑ i = j + 1 n q i × q j ( i − j ) 2 F_j = \sum_{i=1}^{j−1}\frac{q_i×q_j}{(i−j)^2} − \sum_{i=j+1}^n\frac{q_i×q_j}{(i−j)^2} Fj​=∑i=1j−1​(i−j)2qi​×qj​​−∑i=j+1n​(i−j)2qi​×qj​​

E i   =   F i q i E_i~=~\frac{F_i}{q_i} Ei​ = qi​Fi​​

让求 E i E_i Ei​

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

快速数论变换 (NTT)

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 5e6 + 7;
const double PI = acos(-1);
const int p = 998244353, G = 3, Gi = 332748118;
int n, m;
int limit = 1;
int res, ans[N];
int l;
int r[N];
ll a[N], b[N];
ll qpow(ll a, ll b)
{
    ll ans = 1;
    while(b)
    {
        if(b & 1) ans = ans * a % p;
        a = a * a % p;
        b >>= 1;
    }
    return ans;
}

void NTT(ll *A, int type)
{
    for(int i = 0; i < limit; i++)
    {
        if(i < r[i]) swap(A[i], A[r[i]]); ///保证不在换过去
    }
    ///从底层开始合并：
    for(int mid = 1; mid < limit; mid = mid * 2)
    {
        ///待合并区间长度的一半，最开始是长度为1的合并，类似倍增的思想
        ll wn = qpow(G, (p - 1) / (mid * 2));
        if(type==-1) wn = qpow(wn, p - 2);

        for(int len = mid * 2, pos = 0; pos < limit; pos += len)
        {
            ///len是区间的长度，pos是当前的位置
            ll w = 1;
            for(int k = 0; k < mid; k++, w = w * wn % p)
            {
                ///只扫左半部分，蝴蝶变换得到有半部分。
                int x = A[pos + k]; //左半部分
                int y = w * A[pos + mid + k] % p; //有半部分
                A[pos + k] = (x + y) % p;
                A[pos + mid + k] = (x - y + p) % p;
            }
        }
    }

    if(type == 1) return ;
    ll inlimit = qpow(limit, p - 2);
    for(int i = 0; i < limit; i++)
    {
        A[i] = (A[i] * inlimit) % p;
        ///除以我们推出的N。
    }
}

int main()
{
    cin >> n >> m;
    for(int i = 0; i <= n; i++) cin >> a[i], a[i] = (a[i] + p) % p;
    for(int i = 0; i <= m; i++) cin >> b[i], b[i] = (b[i] + p) % p;

    while(limit <= n + m) limit <<= 1, l++;
    for(int i = 0; i <= limit; i++)
    {
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
    }
    NTT(a, 1);
    NTT(b, 1);

    for(int i = 0; i <= limit; ++i)
    {
        a[i] = a[i] * b[i] % p;
    }

    NTT(a, -1);

    for(int i = 0; i <= n + m; i++)  cout << a[i] << " ";

    return 0;
}
林苏泽
关注
  • 11
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
快速傅里叶变换（FFT）（下）
LzyRapX
10-09 3261
关于学习FFT算法的资料个人最推荐的还是算法导论上的第30章(第三版), 多项式与快速傅里叶变换, 基础知识都讲得很全面。 FFT算法基本概念： FFT(Fast Fourier Transformation)即快速傅里叶变换, 是离散傅里叶变换的加速算法, 可以在O(nlogn)O(nlogn)的时间里完成DFT, 利用相似性也可以在同样复杂度的时间里完成逆DFT。 DFT(Dis
傅里叶变换的性质及证明（CTFT）
Norstc的博客
11-06 3万+
1.对称性： 2.尺度变化 3.时移 4.频移 5.周期性 周期信号可以写成指数傅里叶级数形式，对两边取傅里叶变换有： 例：对于周期脉冲序列s(t)： 其傅里叶系数Fn： 那么s(t)的傅里叶变换为：
特殊符号大全(建议收藏_复制着用_数学符号最下面)
热门推荐
红目香薰
09-02 17万+
数字符号 ① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⑾ ⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇ ⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ ⒒ ⒓ ⒔ ⒕ ⒖ ⒗ ⒘ ⒙ ⒚ ⒛ ㊀ ㊁ ㊂ ㊃ ㊄ ㊅ ㊆ ㊇ ㊈ ㊉ ㈠ ㈡ ㈢ ㈣ ㈤ ㈥ ㈦ ㈧ ㈨ ㈩ № ½ ⅓ ⅔ ¼ ¾ ⅛ ⅜ ⅝ ⅞ 希腊数字 Ⅰ Ⅱ Ⅲ Ⅳ Ⅴ Ⅵ Ⅶ Ⅷ Ⅸ Ⅹ Ⅺ Ⅻ ⅰ ⅱ ⅲ ⅳ ⅴ ⅵ ⅶ ⅷ ⅸ ⅹ ⅺ ⅻ 月份符号 ㋀
傅里叶变换的性质及证明
weixin_46702338的博客
02-19 1万+
傅里叶变换的性质及证明 1. 线性性质 F[αf1(t)+βf2(t)]=αF1(ω)+βF2(ω)\qquad F[\alpha f_1(t)+\beta f_2(t)]=\alpha F_1(\omega)+\beta F_2(\omega)F[αf1​(t)+βf2​(t)]=αF1​(ω)+βF2​(ω) 证明： KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ F[\alpha f
十五、多项式乘法与快速傅里叶变换
dinongxu8804的博客
08-13 422
十五、多项式乘法与快速傅里叶变换 前言 经典算法研究系列，已经写到第十五章了，本章，咱们来介绍多项式的乘法以及快速傅里叶变换算法。本博客之前也已详细介绍过离散傅里叶变换（请参考：十、从头到尾彻底理解傅里叶变换算法、上，及十、从头到尾彻底理解傅里叶变换算法、下），这次咱们从多项式乘法开始，然后介绍FFT算法的原理与实现。同时，本文虽涉及到不少数学公式和定理（当然，我会尽量舍去一些与本...
快速傅里叶变换 python源码
11-15
快速傅里叶变换
快速傅里叶变换的C++实现
11-08
快速傅里叶变换 (fast Fourier transform), 即利用计算机计算离散傅里叶变换（DFT)的高效、快速计算方法的统称，简称FFT。快速傅里叶变换是1965年由J.W.库利和T.W.图基提出的。采用这种算法能使计算机计算离散傅里叶...
快速傅里叶变换FFT的C语言实现及应用_fft_快速傅里叶变换_
09-29
快速傅里叶变换（FFT，Fast Fourier Transform）是数字信号处理领域中的一种高效算法，用于计算离散傅里叶变换（DFT）及其逆变换。它由数学家库利（John W. Cooley）和图基（James W. Tukey）在1965年提出，极大地...
基于稀疏快速傅里叶变换的信号压缩处理
10-16
【基于稀疏快速傅里叶变换的信号压缩处理】是一种应对大数据量信号处理问题的创新方法，它解决了传统奈奎斯特采样定理在高采样频率下导致的存储和传输难题。传统的奈奎斯特采样定理规定，采样频率必须大于信号最高...
快速傅里叶变换C#实现
07-27
快速傅里叶变换（FFT，Fast Fourier Transform）是一种在离散信号处理中极其重要的算法，它极大地提高了计算离散傅里叶变换（DFT，Discrete Fourier Transform）的效率。在C#编程环境下，理解并实现FFT对于进行音频...
FFT快速傅里叶变换以O(NlogN)的时间复杂度实现大数乘
08-22 5402
任意一个整数均能表示成An*10^(n-1) + An-1*10^(n-2) + ... + A2*10^2 + A1*10 + A0的形式，视10为自变量X，则化为一个多项式。两数相乘转化为两多项式相乘。以系数表示法表示的多项式相乘其复杂度为N^2，若采用点值表示法，结合适当的点的选取，能实现O(NlogN)的算法。 若一个多项式的最高次为N-1，那么取N个点对(xi, yi)就能够唯一确
【FFT快速傅里叶变换】讲解
Floraqiu的博客
01-22 1344
参考来源： 十分简明易懂的FFT（快速傅里叶变换） 小学生都能看懂的FFT！！！ 一、FFT的介绍 FFT是什么 快速傅里叶变换（FFT）是一种能在 O(nlog⁡n)O(n\log{n})O(nlogn) 的时间内将一个多项式转换成它的点值表示的算法。 FFT的作用 快速计算多项式乘法（即卷积） （还可以用到字符串的模糊匹配） 前置知识 多项式的表示 点值表示法： 实际上就是...
【数论系列】 快速傅里叶变换 FFT算法
Hello World!
07-25 4547
通俗点来说，FFT就是利用某些奇偶特点，进行DFT（离散傅里叶变换）和IDFT（离散傅里叶逆变换）的快速求解算法。
多项式与快速傅里叶变换（FFT）
叶子心情你不懂
10-10 3616
    上次算导老师讲分治高精度乘法（n^1.8左右的复杂度），并且说acm里就有这个、、、、然后我小声bb说acm里高精度快速乘是nlogn的，然后一阵虚因为自己不会FFT。今天算法课又提到了并且我和同学吹牛快速傅里叶变换只要nlogn巴拉巴拉，然后又一阵虚、、、今天晚上就来学一下、、、     两个多项式相乘所需时间是n方，而FFT能把多项式相乘的时间复杂度降为nlogn。     FFT...
多项式乘法 快速傅里叶变换FFT
上总介的博客
06-19 841
简要记录FFT实现原理
【转载】从多项式乘法到快速傅里叶变换 【FFT/NTT】【详细证明】
2016gdgzoi471
04-12 1043
正在学习FFT。在网上无意逛到了一个特别好的blog，内有FFT、NTT等等的详细证明，在征得博主同意后转载了过来。（其实很大程度上是留给自己看的，做个存档^ ^） 原文链接（感谢博主！） ...
莫比乌斯函数
林苏泽
10-18 2万+
目录前导积性函数莫比乌斯函数 前导 要学习莫比乌斯函数 需要学习 到 积性函数，深度理解欧拉筛。 先说说什么是积性函数吧。 积性函数 其实积性函数非常好理解， 定义 积性函数：若gcd(a,b)=1，且满足f(ab)=f(a)f(b)，则称f(x)为积性函数 完全积性函数：对于任意正整数a，b，都满足f(ab)=f(a)f(b)，则称f(x)为完全积性函数 性质 1.若f(n),g(n)均为积性函数，则函数h(n)=f(n)g(n)也是积性函数 2.若f(n)为积性函数，则函数c*f(n)(c是常数)也是积
2021年度训练联盟热身训练赛第一场 C.New Math
林苏泽
03-09 2161
题目链接 题目大意： 定义一种不进位乘法和加法，给出n让你求出a使得a*a=n 先看定义的不进位的乘法和加法。 看下这个图理解一下，就是每一位的乘法不进位，然后每一位的加法也不进位。 通过a∗a=na*a=na∗a=n我们其实可以知道如果aaa的位数为xxx那么nnn的位数应该是2∗x−1=m2*x-1=m2∗x−1=m，mmm为nnn的位数。所以我们可以通过nnn的位数得到aaa的位数，也可以通过是否是奇数判断是否可能有解。 我们可以通过固定的位数来判断对应的结果对应的位数。(从后从前都一样)
数字全排列
林苏泽
02-21 1566
题意； 从1～9之间顺序取N个数字，组成每位数不重复的所有可能的N位数，按从小到大的顺序进行编号，当输入其中的任何一个数M是，能找出该数对应的编号。如：当N ＝ 3，M = 132时，则输出： [123(1), 132(2), 213(3), 231(4), 312(5), 321(6)]——> X = 2 Input 输入只有一行，两个正整数N和M(1 ≤ N ≤ 9，1 ≤ K ≤ 98...
"Matlab快速傅里叶变换与逆变换的指令及格式
“matlab快速傅里叶变换ppt课件.ppt；matlab快速傅里叶变换ppt课件.ppt;§4.5 快速傅里叶变换 §4.5.1 离散傅里叶变换.1 利用得 .2 以此类推，傅里叶变换的逆变换为即 F4的逆矩阵为.3说明 .45§4.5.2 傅里叶级数与...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值