【ACM训练六】数论入门

素数问题

素数判定

枚举：2-n（时间复杂度：O（n））
优化：2-[√n] （时间复杂度：O（√n））

素数筛

如何筛出2到n中所有素数？
枚举：时间复杂度O（n√n）
素数筛：通过预处理，做到每次O（1）判断一个数（某个范围内）是否为素数。

埃氏筛：初始将所有数(从2 开始) 默认为素数，从小到大遍历每个数x，如果x 是素数，那么将2x,3x,4x……划掉，即标记成非素数
优化：每次改为划掉x²，x² + x， x² + 2x……（降低同一个数被重复划掉的可能性）
时间复杂度O(nloglogn)
实例：求数n以内的所有素数

转载自博客https://www.cnblogs.com/Aikoin/p/10180157.html

#include <iostream>
#include <cstring>
using namespace std;

//埃氏筛法

const int MAX_N = 10005;
int prime[MAX_N];  //第i个素数
bool is_prime[MAX_N+1];  //is_prime[i]为true时表示i是素数

//返回n以内素数的个数
int sieve(int n){
    int p = 0;
    for(int i = 0; i <= n; i++) is_prime[i] = true;
    is_prime[0] = is_prime[1] = false;
    for(int i = 2; i <= n; i++){
        if(is_prime[i]){
            prime[p++] = i;
            for(int j = 2*i; j <= n; j+=i) is_prime[j] = false;  //筛去所有素数的倍数
        }
    }
    return p;
}


int main()
{
    int n;  //枚举n以内素数
    while(cin>>n){
       int p = sieve(n);
        cout<<p<<endl;
        for(int i = 0; i < p;i++)
            cout<< prime[i]<<" ";
        cout<<endl;
    }

    return 0;
}

欧拉筛（线性筛）：每个合数只被筛一次，关键是只用每个数的最小素因子去筛，时间复杂度O(n)。
实例：求2-n内的所有素数。

参考博客：https://lusto.cn/2019/03/18/欧拉筛/

#include<bits/stdc++.h>//万能库
using namespace std;
#define ll long long
#define ull unsigned long long

const int inf=0x3f3f3f;
int n,t;
int prime[100001];
bool v[100001];
int ct=0;

void ola(int n)
{
	for(int i=2;i<=n;++i)
	{
		if(!v[i])
			prime[ct++]=i;
		for(int j=0;j<ct&&i*prime[j]<=n;++j)
		{
			v[i*prime[j]]=true;
			if(i%prime[j]==0)break;//实现O(n)的关键所在
		}
	}
}

int main()
{
   cin>>n;
   ola(n);//n以内的素数
   for(int i=0;i<ct;++i)
   	cout<<prime[i]<<endl;
}

最大公约数

两个数a,b的最大公约数记作gcd(a,b)
基本性质
gcd(a,b) = gcd(b,a)
gcd(a,0) = |a|
gcd(a,ka) = |a| 对任意k为整数
gcd(na， nb) = n gcd(a， b) 对任意n为整数

欧几里得算法（辗转相除法，是指用于计算两个正整数a，b的最大公约数）
任何数与0的最大公约数是它本身，所以一直操作直到b = 0时的a就是原a，b的最大公约数了。
求a,b最大公约数：

#include <cstdio>
using namespace std;
int minn(int a, int b)
{
	if (b==0)
	return a;
	else
	return minn(b,a%b);
}
int main()
{
	int a,b;
	while(scanf("%d %d",&a,&b)!=EOF)
	printf("%d",minn(a,b));
	return 0;
}

扩展欧几里得算法

int exGcd(int a,int b,int &x,int &y)
{
    if(b==0)
    {
        x = 1;
        y = 0;
        return a;
    }
    int r = exGcd(b,a%b,x,y);
    t = x; x = y;
    y = t-a/b*y;
    return r;
}

裴蜀定理

转自 https://blog.csdn.net/kylin_black/article/details/81710831

定理：若a,b是整数,且gcd（a,b)=d，那么对于任意的整数x,y,ax+by都一定是d的倍数，特别地，一定存在整数x,y，使ax+by=d成立。

它的一个重要推论是：a,b互质的充要条件是存在整数x,y使ax+by=1.
设a1,a2,a3…an为n个整数，d是它们的最大公约数，那么存在整数x1…xn使得x1a1+x2a2+…xn*an=d。

特别来说，如果a1…an互质（不是两两互质），那么存在整数x1…xn使得x1a1+x2a2+…xn*an=1。

例题：
你需要设计一套纸币系统， 现在已经有了 n 种不同样式的纸币，你只需要为它们设计面值。 每种纸币的面值都是 B 的约数（不同种纸币面值可以相同） ， 但是 B 还未知， 只知道 L<=B<=R,在这个国家，支付时会给定 d， 只要支付的总额模 K 与 d 同余即可。 为了让人们能应对支付时给出不同 d 的所有情况（假设可以使用的纸币没有限制），请问你在 B 取值的所有可能性下设计方案数的和。答案对 998244353 取模。

#include<iostream>
using namespace std;
const int N=10001000;
const long long MOD=998244353;
int L,R,pr[N],a[N];
long long K,m,mi[200],f[N];
long long pow(long long a,long long b){
    long long re=1;
    while(b){
        if(b&1) re=re*a%MOD;
        a=a*a%MOD,b>>=1;
    }
    return re;
}
int main(){
   cin>>L>R>>K>>m;
    for(int i=0;i<=100;i++) mi[i]=pow(i,m);
    for(int i=2;i<=10000000;i++){
        if(!a[i])
            pr[++pr[0]]=i,a[i]=1;
        for(int j=1;j<=pr[0]&&1LL*i*pr[j]<=10000000;j++)
            if(i%pr[j]==0){
                a[i*pr[j]]=a[i];
                break;
            }
			else a[i*pr[j]]=i;
    }
    for(int i=1;i<=pr[0];i++)
        if(K%pr[i]==0)
            for(long long j=1,t=pr[i];t<=10000000;j++,t*=pr[i])
                f[t]=(mi[j+1]-mi[j]+MOD)%MO
		else
            for(long long j=1,t=pr[i];t<=10000000;j++,t*=pr[i])
                f[t]=mi[j+1];
        }
    f[1]=1;
    for(int i=2;i<=10000000;i++)
        if(a[i]>1)
            f[i]=f[a[i]]*f[i/a[i]]%MOD;
    for(int i=2;i<=10000000;i++)
        f[i]=(f[i-1]+f[i])%MOD;
    cout<<(f[R]-f[L-1]+MOD)%MOD;
    return 0;
}

同余运算 乘法逆元

同余问题题集：https://blog.csdn.net/qq_34416123/article/details/83032337

费马小定理

大佬博客：https://blog.csdn.net/li1615882553/article/details/79997662

中国剩余定理

大佬博客：https://blog.csdn.net/niiick/article/details/80229217

快速幂

反复平方法

参考博客 https://www.cnblogs.com/sun-of-Ice/p/9330352.html

typedef long long ll;
ll mod;
ll qpow(ll a, ll n)//计算a^n % mod
{
    ll re = 1;
    while(n)
    {
        if(n & 1)//判断n的最后一位是否为1
            re = (re * a) % mod;
        n >>= 1;//舍去n的最后一位
        a = (a * a) % mod;//将a平方
    }
    return re % mod;
}