数论整理

最新推荐文章于 2021-07-11 16:26:27 发布

原创最新推荐文章于 2021-07-11 16:26:27 发布 · 253 阅读

0 ·

CC 4.0 BY-SA版权

模板专栏收录该内容

6 篇文章

订阅专栏

人总要活成自己不喜欢的样子，然后我有一天也要学数论了，虽然也算不上学习。
线筛

#include<cstdio>
const int N = 100000 + 5;
bool prime[N];//prime[i]表示i是不是质数 
int p[N], tot;//p[N]用来存质数 
void init(){
    for(int i = 2; i < N; i ++) prime[i] = true;//初始化为质数 
    for(int i = 2; i < N; i++){
        if(prime[i]) p[tot ++] = i;//把质数存起来 
        for(int j = 0; j < tot && i * p[j] < N; j++){
            prime[i * p[j]] = false;
            if(i % p[j] == 0) break;//保证每个合数被它最小的质因数筛去 
        }
    }    
}
int main(){
    init();
}

线筛原理：对于i，我们只删除i的整倍数中，最大质因子比i里面最小的质因子还小的数，就相当于我们保证每个数被访问的时候的最小质因子是prime里的数，这样的话，就不会重复了。

欧拉函数，
欧拉函数是用来求一个数p在1到p里面有多少个数与它互质，
那么可以用一个数的质因子去实现，用这些质因子组合起来的数就是和p不互质的数，减去这些就行了，
那么怎么找出这些数呢，这个时候可以用到一个东西叫做莫比乌斯系数，但是很慢，然后就用一个很好的容斥
p*(1-1/p1)*(1-1/p2),,,(1-1/pk) ,p1,p2,,,pk为p的质因子，
然后根据上面这个式子，可以得到一个结论
对于一个质数p，
phi（p*i） = (p-1)*phi(i){i%p != 0};
phi(p*i) = p*phi(i){i%p == 0};
证明的话，如果i%p == 0;那么p的所有因子都是i的因子，那么用p*i*(1-1/p1)(1-1/p2),,这个式子算p*i的质因子的时候，可以发现后面的时一样的，所有直接乘以p就好了，如果i%p！=0，那么 p*i,,,后面的要比i的多一个1-1/p，前面多了一个p，所以就是多了一个(p-1);然后用埃塞相似的方法，就可以得到o（n）的算法了，
某学长的博客 https://www.cnblogs.com/linyujun/p/5194170.html

#include<cstdio>
using namespace std;
const int N = 1e6+10 ;
int phi[N], prime[N];
int tot;//tot计数，表示prime[N]中有多少质数 
void Euler(){
    phi[1] = 1;
    for(int i = 2; i < N; i ++){
        if(!phi[i]){
            phi[i] = i-1;
            prime[tot ++] = i;
        }
        for(int j = 0; j < tot && 1ll*i*prime[j] < N; j ++){
            if(i % prime[j]) phi[i * prime[j]] = phi[i] * (prime[j]-1);
            else{
                phi[i * prime[j] ] = phi[i] * prime[j];
                break;
            }
        }
    }
}

int main(){
    Euler();
}

欧拉定理，如果gcd(a,p) == 1,那么a^(phi(p))%p =1;

莫比乌斯系数，
mu[i] = 1{i==1}
mu[i] = -1{i有奇数个质因子，且没有重复的）
mu[i] = 1{i有偶数个质因子，且没有重复的）
mu[i] = 0{i有重复的质因子}；
用线筛的思想也可以处理莫比乌斯系数；


#include<bits/stdc++.h>
using namespace std;
const int N = 1e5+7;
int mu[N];
int cnt = 0,tot = 0;
bool vis[N];
int prime[N];
void init(){
    mu[1]=1;
    for(int i = 2;i < N;i ++){
        if(!vis[i])prime[tot++]=i,mu[i]=-1;
        /*for(int j=1;j<=cnt;j++){
            int t=i*prime[j];
            if(t>=N)break;
            mark[t]=1;
            if(i%prime[j]==0){mu[t]=0;break;}
            else mu[t]=-mu[i];
        }*/
        //cout << i << ' '<<tot<<' '<<prime[0] <<  endl;
        for(int j = 0;j < tot && 1LL*prime[j]*i < N;j ++){
            vis[i*prime[j]] = true;
            if(i%prime[j] == 0) {mu[i*prime[j]] = 0;break;}
            else mu[i*prime[j]] =-mu[i];
        }
    }
}

int main(){
    init();
    return 0;
}

莫比乌斯系数的用处：求1到n之间有多少个数和1互质，就是用莫比乌斯系数。
比如果我们想知到1到n之间有多少个数和1互质，那么我们可以知道1到n有多少个数是1，2，3，，，n，的倍数，
那么我们就可以用这些数和莫比乌斯系数做容斥找出有多少个数和1互质，并且用这个算出来有多个数和x互质，
比如，其实与x互质的个数就是n/x个数里面有多少个数与1互质，这看似没有什么用，但是如果你想知道x（1-n），y（1-m），有n*m种组合，如果想知道这里面有多少个组合的gcd分别有多少种，那么就可以用莫比乌斯系数了，因为我们可以知道在这些组合中有多少个组和的gcd是1某个数的多少，假如我们要求gcd为x的数量，那么我们可以知道gcd为x的倍数有
n/x*m/x个，gcd为2*x的倍数的个数有n/(2*x)*m/(2*x)个，然后这个就转化成上一个问题了，然后就可以用莫比乌斯系数了，
复杂度是nlogn。
然后还有一种做法也是nlogn的，就是用cnt[i]代表gcd为i的种类数，那么如果我们从min(n,m)枚举到1，对于x，我们可以知道gcd为x的倍数的个数是n/x*m/x,然后减去gcd为2*x，3*x，，然后剩下的就是gcd为x的个数了，复杂度也是nlogn。
hdu 6390 两种写法
https://paste.ubuntu.com/p/HKyPhKpwzx/
https://paste.ubuntu.com/p/NCp9GG39p9/

fft :大佬写的理解，有一点是idft的时候，乘的是逆矩阵
https://blog.youkuaiyun.com/leo_h1104/article/details/51615710
中国剩余定理：https://blog.youkuaiyun.com/tick_tock97/article/details/71313058