ACM 数论模板

快速幂

/*******快速幂********/
typedef long long LL;   //  视数据大小的情况而定
LL powerMod(LL x, LL n, LL m){//求解 x的n次方 并求模于m 

    if(n==0) return 1;
    LL res = 1;
    while (n > 0){
        if  (n & 1) //  判断是否为奇数，若是则true
            res = (res * x) % m;
        x = (x * x) % m;
        n >>= 1;    //  相当于n /= 2;
    }
    return res;v
}

gcd

gcd 和 lcm

• 递归版本

/*求最大公约数*/
int gcd(int a, int b){
    return b ? gcd(b, a % b) : a;
}

• 循环版本

int gcd(int big, int small)//gcd求 big与small 的最大公约数 {
    if (small > big) swap(big, small); //要加个void swap(int &a,int &b){int tmp=a;a=b;b=tmp;}
    int temp;
    while (small != 0){ //  辗转相除法
        if (small > big) swap(big, small);
        temp = big % small;
        big = small;
        small = temp;
    }
    return(big);
}

扩展gcd

// 求x, y，使得ax + by = gcd(a, b)
int exgcd(int a, int b, int &x, int &y){
    if (!b){
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= (a/b) * x;
    return d;
}

素数

素数判定 需要加头文件、快速幂

/****米勒罗宾素数检测（Miller-Rabin）***/
typedef long long LL;
bool Miller_Rabbin(LL x){
    srand((unsigned)time(0));
    if (x == 1) return false;
    if (x == 2) return true;
    for (LL i = 1; i <= 30; ++i){
        LL now = rand()%(x-2) + 2; //加上 #include <cstdlib> 和 #include <ctime>
        if (pow(now, x-1, x) != 1) return false; //加上快速幂 LL pow(LL a, LL x, LL mod)
    }
    return true;
}

素数筛法

/*****线性筛法****/ 
const int maxn = 10000009;//最大的数的大小 
int prime[maxn];  //第i个素数，从0开始，结尾不是maxn，是prime_num[n]
bool is_prime[maxn]; // i是否为素数
int sieve(int N){
    int cnt = 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[cnt++] = i;
    for (int j = 0; j < cnt&&prime[j] * i <= N; j++) {
        is_prime[prime[j] * i] = 0;
        if (i%prime[j] == 0)
            break;
        }
    }
}

区间筛

• 使用场景：给定整数a和b，请问区间[a,b)内有多少个素数？

#define LL long long
#define MAX_L 1000007
#define MAX_SORT_B 1000007
bool is_prime[MAX_L];
bool is_prime_small[MAX_SORT_B];

//对区间[a,b)内的整数执行筛法。isprime[i - a]=true <=> i是素数
void segment_sieve(LL a,LL b){
    for(int i=0; (LL)i*i < b; i++)is_prime_small[i]=true;
    for(int i=0; i<b-a; i++)is_prime[i]=true;
    for(int i=2; (LL)i * i<b; i++){
        if(is_prime_small[i]){
            for(int j=2*i; (LL)j * j < b; j += i) is_prime_small[j]=false;//筛[2,sqrt(b))
            for(LL j=max(2LL, (a+i-1)/i)*i ; j<b; j+=i){ //(a+i-1)/i为[a,b)区间内的第一个数至少为i的多少倍.
                is_prime[j - a] =false;//筛[a,b)
            }
        }
    }
}

• 使用

        segment_sieve(a,b);
        int cnt=0;
        for(int j=0; j<b-a; j++){
            if(is_prime[j])cnt++;
        }
        if(a==1)cnt--;
        printf("%d\n",cnt);
        //cnt 为 (a,b)内素数的个数

欧拉

欧拉函数

• 就是对于一个正整数n，小于n且和n互质的正整数（包括1）的个数，记作φ(n) 。

int phi(int x){
    int res = x;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0){
            res = res / i * (i - 1);
            while (x % i == 0) x /= i;
        }
    if (x > 1) res = res / x * (x - 1);
    return res;
}

欧拉筛

int primes[N], cnt;     // primes[]存储所有素数
int euler[N];           // 存储每个数的欧拉函数
bool st[N];         // st[x]存储x是否被筛掉

void get_eulers(int n){
    euler[1] = 1;
    for (int i = 2; i <= n; i ++ ){
        if (!st[i]){
            primes[cnt ++ ] = i;
            euler[i] = i - 1;
        }
        for (int j = 0; primes[j] <= n / i; j ++ ){
            int t = primes[j] * i;
            st[t] = true;
            if (i % primes[j] == 0){
                euler[t] = euler[i] * primes[j];
                break;
            }
            euler[t] = euler[i] * (primes[j] - 1);
        }
    }
}

中国剩余定理

• 在《孙子算经》中有这样一个问题：“今有物不知其数，三三数之剩二（除以3余2），五五数之剩三（除以5余3），七七数之剩二（除以7余2），问物几何？”这个问题称为“孙子问题”，该问题的一般解法国际上称为“中国剩余定理”。

//中国剩余定理模板
typedef long long ll;
ll china(ll a[],ll b[],int n)//a[]为除数，b[]为余数
{
    ll M=1,y,x=0;
    for(int i=0;i<n;++i)  //算出它们累乘的结果
        M*=a[i];
    for(int i=0;i<n;++i)
    {
        ll w=M/a[i];
        ll tx=0;
        int t=exgcd(w,a[i],tx,y);  //计算逆元
        x=(x+w*(b[i]/t)*x)%M; 
    }
    return (x+M)%M;
}

乘法求逆元

• 满足 a * k ≡ 1 (mod p) 的k 叫做 a关于p的乘法逆元。另一种表达方法是 k ≡ a-1 (mod p)

• 求(a/b)%p时，可能会因为a是一个很大的数，不能直接算出来

a / b = a * b-1 (mod p )
= (a mod p ) * (b-1 mod p ) mod p
= (a mod p ) * (k mod p ) mod p
= a * k mod p

转换为a*k % p 的问题，然后a是一个加减乘的式子
k 为 b 关于 p 的逆元

int inv(int a, int n)///a在模n乘法下的逆元,没有则返回-1(a * b % n == 1,已知a,n,求b就是乘法逆元)
{  
    int x, y;  
    int t = Ext_gcd(a, n, x, y);///扩展欧几里得算法
    if(t != 1)  
        return -1;  
    return (x % n + n) % n;  
}

线性时间递推

LL inv[maxn];
void Inv(){
	inv[0] = inv[1] = 1;
	for(LL i = 2;i < maxn;i++){
		inv[i] = (Mod - Mod/i)*inv[Mod%i]%Mod;
	}
}

/****(a*b) % mod, a、b 很大时要用到
LL multi(LL a, LL b, LL m)
{
	LL exp = a % m, res = 0;
	while (b)
	{
		if (b & 1)  		//b的最低位是否为1 
		{
			res = res + exp;
			if (res >= m)
				res = res -m;
		}
		exp = exp *2;
		if (exp > m)
			exp = exp - m;
		b >>= 1; 			//将b除以2 
	}
	return res;
} 

卡特兰数

给定n个0和n个1，它们按照某种顺序排成长度为2n的序列，满足任意前缀中0的个数都不少于1的个数的序列的数量为： Cat(n) = C(2n, n) / (n + 1)

• 应用场景
  比如：从左到右的所有序列中0（左括号）的个数要一直大于1（右括号）的个数。

推广：从左到右的所有序列中“某个约束” 的个数要一直大于非约束 的个数。

约数个数 和 约数之和

如果 N = p1^c1 * p2^c2 * … *pk^ck

约数个数： (c1 + 1) * (c2 + 1) * … * (ck + 1)

const int N=1e5+5;
bool mark[N];
int prim[N],d[N],num[N];
int cnt;
void initial(){
    cnt=0;
    d[1]=1;
    for (int i=2 ; i<N ; ++i){
        if (!mark[i]){
            prim[cnt++]=i;
            num[i]=1;
            d[i]=2;  
        }
        for (int j=0 ; j<cnt && i*prim[j]<N ; ++j){
            mark[i*prim[j]]=1;
            if (!(i%prim[j])){
                num[i*prim[j]]=num[i]+1;
                d[i*prim[j]]=d[i]/(num[i]+1)*(num[i*prim[j]]+1);
                break;
            }
            d[i*prim[j]]=d[i]*d[prim[j]];
            num[i*prim[j]]=1;
        }
    }
}

约数之和： (p1^0 + p1^1 + … + p1^c1) * … * (pk^0 + pk^1 + … + pk^ck)

const int N=1e5+5;
bool mark[N];
int prim[N];
long long sd[N],sp[N];
int cnt;
void initial(){
    cnt=0;
    sd[1]=1;
    for (int i=2 ; i<N ; ++i){
        if (!mark[i]){
            prim[cnt++]=i;
            sd[i]=i+1;
            sp[i]=i+1;}
        for (int j=0 ; j<cnt && i*prim[j]<N ; ++j){
            mark[i*prim[j]]=1;
            if (!(i%prim[j])){
                sp[i*prim[j]]=sp[i]*prim[j]+1;
                sd[i*prim[j]]=sd[i]/sp[i]*sp[i*prim[j]];
                break;
            }
            sd[i*prim[j]]=sd[i]*sd[prim[j]];
            sp[i*prim[j]]=1+prim[j];
        }
    }
}

组合数

LL C(int m,int n) {
    int k=1;//相当于C(m,n)
    LL ans=1;
    while(k<=n) {
        ans=((m-k+1)*ans)/k;
        k++;
    }
    return ans;
}

// c[a][b] 表示从a个苹果中选b个的方案数
for (int i = 0; i < N; i ++ )
    for (int j = 0; j <= i; j ++ )
        if (!j) c[i][j] = 1;
        else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;

分解质因数法求组合数

当我们需要求出组合数的真实值，而非对某个数的余数时，分解质因数的方式比较好用：
1. 筛法求出范围内的所有质数
2. 通过 C(a, b) = a! / b! / (a - b)! 这个公式求出每个质因子的次数。 n! 中p的次数是 n / p + n / p^2 + n / p^3 + …
3. 用高精度乘法将所有质因子相乘

int primes[N], cnt;     // 存储所有质数
int sum[N];     // 存储每个质数的次数
bool st[N];     // 存储每个数是否已被筛掉

void get_primes(int n){      // 线性筛法求素数
    for (int i = 2; i <= n; i ++ ){
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ ){
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

int get(int n, int p){       // 求n！中的次数
    int res = 0;
    while (n){
        res += n / p;
        n /= p;
    }
    return res;
}

vector<int> mul(vector<int> a, int b){       // 高精度乘低精度模板
    vector<int> c;
    int t = 0;
    for (int i = 0; i < a.size(); i ++ ){
        t += a[i] * b;
        c.push_back(t % 10);
        t /= 10;
    }

    while (t){
        c.push_back(t % 10);
        t /= 10;
    }
    return c;
}

get_primes(a);  // 预处理范围内的所有质数

for (int i = 0; i < cnt; i ++ ){     // 求每个质因数的次数
    int p = primes[i];
    sum[i] = get(a, p) - get(b, p) - get(a - b, p);
}

vector<int> res;
res.push_back(1);

for (int i = 0; i < cnt; i ++ )     // 用高精度乘法将所有质因子相乘
    for (int j = 0; j < sum[i]; j ++ )
        res = mul(res, primes[i]);