目录
一、质数的判定
1. 试除法判定质数
2. 质因数的分解
3. 质数筛选法（埃氏筛法+线性筛）
4. 米勒罗宾素数检测法（快速判断大质数）
二、约数相关
（1）试除法求约数
（2）求约数个数或约数之和
（3）求最大公因数 / 最小公倍数
三、欧几里得算法
（1）扩展欧几里得算法
（2）线性同余方程
四、快速幂
（1）快速幂算法
（2）大数快速幂（降幂公式）
（3）快速幂求逆元（费马小定理）
五、欧拉函数
六、组合数学
七、高斯消元
八、容斥原理
九、中国剩余定理/扩展中国剩余定理
十、其他
1. 威尔逊定理
2. …
注：以下模板题均可在 ACwing 题库中找到
一、质数的判定
1. 试除法判定质数
bool isprime(int x)
{
if(x<=1)
return false;
for(int i=2;i<=x/i;i++)
{
if(x%i==0)
return false;
}
return true;
}
2. 质因数的分解
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
while(n--)
{
int x;
cin>>x;
for(int i=2;i<=x/i;i++)
{
int p=0;
while(x%i==0)
{
x/=i;p++;
}
if(p)
cout<<i<<' '<<p<<endl;
}
if(x>1)
cout<<x<<" "<<1<<endl;
cout<<endl;
}
return 0;
}
3. 质数筛选法（埃氏筛法+线性筛）
（1）埃氏筛法
基本原理：从小到大将每个质数的倍数筛去
若某个数没有被它前面的数筛掉，那么它一定是质数。
原因：它不是前面的2~p-1中任何一个数的倍数，那么它是质数
时间复杂度：n*log(log(n))，接近线性
const int N = 1e6+5;
bool isprime[N];
int prime[N];
int cnt;
void init(int n)
{
isprime[1]=true;
for(int i=2;i<=n;i++)
{
if(!isprime[i])
{
prime[++cnt]=i;
for(int j=i+i;j<=n;j+=i)
isprime[j]=true;
}
}
}
（2）线性筛法
基本原理：每个数只会被它最小的质因数筛掉，那么每个数只会被筛一次，所以时间复杂度为o(n)
const int N = 1e6+5;
bool isprime[N];
int prime[N];
int cnt;
void init(int n)
{
isprime[1]=true;
for(int i=2;i<=n;i++)
{
if(!isprime[i])
prime[cnt++]=i;
for(int j=0;prime[j]<=n/i;j++)
{
isprime[prime[j]*i]=true;
if(i%prime[j]==0)
break;
}
}
}
4. 米勒罗宾素数检测法（快速判断大质数）
适用范围：较大数的较快素性判断
原理是费马小定理：如果p是素数，则a ^ (p-1)%p == 1，加上二次探测定理：如果p是一个素数，则x^2%p==1的解为，则x=1或者x=n-1。
一次检测中：
主要是把一个数n的n-1分解成d*2^ r的形式，其中d为奇数，正向过程是a^ n%p如果是1，就继续分解
a^ (n/2)%p，（a为一个与n互素的数）看是否为1,；如果是n-1就停止分解，说明至此无法判断是否为素数；如果不等于这两个值，则一定为合数。而在写代码过程是这个过程的逆向过程，先分解到底，看最后这个a^d%p是否为1或n-1，如果是说明已经分解到底了，也就是通过了此次素性测试。如果不是，说明在正向过程中出现了要么a的某次方为n-1，根据算法停止了检测过程；要么就是中间的某一个结果不等于这两个数，那么就是合数。就从最后往前面推，每一步看满不满足上述条件。直到判断为合数或者终止检测的那一步。
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll q_mul(ll a,ll b,ll p)
{
ll ans=0;
while(b)
{
if(b&1)
ans=(ans+a)%p;
a=(a<<1)%p;
b>>=1;
}
return ans;
}
ll q_pow(ll a,ll b,ll p)
{
ll ans=1;
while(b)
{
if(b&1)
ans=q_mul(ans,a,p);
a=q_mul(a,a,p);
b>>=1;
}
return ans;
}
bool Miller_Rabin(ll n){
if(n==2)return true;
if(n<2||!(n&1))return false;
int t=2,r=0;
ll m=n-1;
while(m%2==0){
r++;
m>>=1;
}
srand(100);
while(t--)
{
ll a=rand()%(n-1)+1;
ll x=q_pow(a,m,n),tmp=0;
for(int i=0;i<r;i++){
tmp=q_mul(x,x,n);
if(tmp==1&&x!=1&&x!=n-1)return false;
x=tmp;
}
if(tmp!=1)return false;
}
return true;
}
部分借鉴自 大神博客
二、约数相关
1. 试除法求约数
void get_ans(int n)
{
vector<int> ans;
for(int i=1;i<=n/i;i++)
{
if(n%i==0)
{
ans.push_back(i);
if(i!=n/i)
ans.push_back(n/i);
}
}
sort(ans.begin(),ans.end());
for(auto x:ans) cout<<x<<" ";
cout<<endl;
}
2. 求约数个数或约数之和
原理：唯一分解定理
任意正整数 n = (a1 ^ p1) * (a2 ^ p2) * (a3 ^ p3) … * (ak ^ pk)
其中a1…ak均为质数
那么约数之和 sum=(p1+1) * (p2+1) * (p3+1) … (pk+1)
即对第一个质因子可以有p1+1种选法，一直到对第k个质因子，有pk+1种选法，把选中的数乘起来就是总约数个数
#include<iostream>
#include<unordered_map>
using namespace std;
typedef long long ll;
const int mod =1e9+7;
int main()
{
int n;
cin>>n;
unordered_map<int,int> mp;
while(n--)
{
int x;
cin>>x;
for(int i=2;i<=x/i;i++)
while(x%i==0)
{
x/=i;
mp[i]++;
}
if(x>1)
mp[x]++;
}
ll ans=1,ans2=1; //分别为约数个数，约数之和
for(auto x: mp)
{
int t=x.first,tt=x.second;
ll res=1;
while(tt--) res=(res*t+1)%mod;
ans=ans*res%mod;
ans2=ans2*(x.second+1)%mod;
}
cout<<ans<<" "<<ans2<<endl;
return 0;
}
3. 求最大公因数 / 最小公倍数
int gcd(int a,int b)
{
return b?gcd(b,a%b):a;
}
int lcm(int a,int b)
{
return a/gcd(a,b)*b;
}
三、欧几里得算法
1. 扩展欧几里得算法
（1）求ax+by=gcd(a,b)的任意一组解：
因为gcd(a,b)=gcd(b,a%b)
为计算方便 , 递归的时候交换x,y位置，那么原式就变为
by+(a%b)x=gcd(a,b)
=>by + ( a - a / b (下取整) * b) * x = gcd(a,b)
=>ax + b(y - a / b * x) = gcd(a,b)
#include<iostream>
using namespace std;
int exgcd(int a,int b,int &x,int &y)
{
if(!b)
{
x=1;y=0;
return a;
}
int r=exgcd(b,a%b,y,x);
y-=a/b*x;
}
int main()
{
int n;
cin>>n;
while(n--)
{
int x,y,a,b;
scanf("%d%d",&a,&b);
int r=exgcd(a,b,x,y);
printf("%d %d\n",x,y);
}
return 0;
}
（2）求ax+by=c的解
若c%gcd(a,b)！=0那么无解
根据上面求出一组x0, y0满足a * x0 + b * y0 = gcd(a,b)
令d=c/gcd(a,b), t=c/d
ax0+by0=d
ab/d+ax0-ab/d+by0=d
a(x0+b/d)-b(y0-a/d)=d
两边同时乘以t， 即解得 x=(x0+b/d)*t, y=(y0-a/d)*t
#include<iostream>
using namespace std;
int exgcd(int a,int b,int &x,int &y)
{
if(!b)
{
x=1;y=0;
return a;
}
int r=exgcd(b,a%b,y,x);
y-=a/b*x;
}
int main()
{
int a,b,c,x0,y0,x,y;
scanf("%d%d%d",&a,&b,&c);
int d=exgcd(a,b,x0,y0);
if(c%d!=0)
printf("no solution\n");
else
{
int t=c/d;
x=(x0+b/d)*t;
y=(y0-a/d)*t;
printf("x=%d y=%d\n",x,y);
}
return 0;
}
2. 线性同余方程
给定n组数据ai,bi,mi，对于每组数求出一个xi，使其满足ai∗xi≡bi(mod mi)，如果无解则输出impossible。
输入格式
第一行包含整数n。
接下来n行，每行包含一组数据ai,bi,mi。
输出格式
输出共n行，每组数据输出一个整数表示一个满足条件的xi，如果无解则输出impossible。
每组数据结果占一行，结果可能不唯一，输出任意一个满足条件的结果均可。
输出答案必须在int范围之内。
数据范围
1≤n≤105,
1≤ai,bi,mi≤2∗109
输入样例：
2
2 3 6
4 3 5
输出样例：
impossible
7
#include<iostream>
using namespace std;
typedef long long ll;
int exgcd(int a,int b,int &x,int &y)
{
if(!b)
{
x=1;y=0;
return a;
}
int r=exgcd(b,a%b,y,x);
y-=a/b*x;
return r;
}
int main()
{
int n;
cin>>n;
while(n--)
{
int a,b,m,x,y;
scanf("%d%d%d",&a,&b,&m);
int d=exgcd(a,m,x,y);
if(b%d)
printf("impossible\n");
else
{
printf("%d\n",(ll)x*(b/d)%m);
}
}
return 0;
}
四、快速幂
1. 快速幂算法
typedef long long ll;
ll q_pow(int a,int b,int p)
{
ll ans=1;
while(b)
{
if(b&1) ans=(ll)ans*a%p;
b>>=1;
a=(ll)a*a%p;
}
return ans%p;
}
2. 大数快速幂（降幂公式）
/*当你要计算 A^B%C的时候
如果B很大，达到10^100000，所以我们应该联想到降幂公式。
降幂公式：A^B%C = A^(B%phi(C) + phi(C))%C
分两种情况：
当B<=phi(C)时，直接用快速幂计算A^B mod C
当B>phi(C)时，用快速幂计算A^(B mod phi(C)+phi(C)) mod C
*/
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstdlib>
using namespace std;
const int mod = 1e9+7;
typedef long long ll;
ll phi(ll n) //求欧拉函数值
{
int ans=n,temp=n;
for(int i=2;i*i<=temp;i++)
{
if(temp%i==0)
{
ans-=ans/i;
while(temp%i== 0) temp/=i;
}
}
if(temp>1) ans-=ans/temp;
return ans;
}
ll mod_pow(ll x,ll n,ll mod) //快速幂
{
ll ans=1;
while(n)
{
if(n%2==1) ans=ans*x%mod;
x=x*x%mod;
n/=2;
}
return ans;
}
ll a,c;
char b[1000010];
int main()
{
while(scanf("%lld%s%lld",&a,b,&c)!=EOF)
{
c%=mod;
a%=mod;
ll phic=phi(mod);
int i,len=strlen(b);
ll res=0,ans;
for( i=0;i<len;i++)
{
res=res*10+b[i]-'0';
if(res>phic)
break;
}
if(i==len)
{
ans=mod_pow(a,res,mod)*c%mod;
}
else
{
res=0;
for(int i=0;i<len;i++)
{
res=res*10+b[i]-'0';
res%=phic;
}
ans=mod_pow(a,res+phic,mod)*c%mod;
}
cout<<ans<<endl;
}
//cout<<mod_pow(2,3,mod);
return 0;
}
以上模板转自：大神博客
3. 快速幂求逆元（费马小定理）
费马小定理：如果p是一个质数，而整数a不是p的倍数，则有 a ^（p-1）≡1（mod p）
应用：(a / b) % p = a * q_pow( b, p-2 ) % p
五、欧拉函数
1. 直接求与n互质的数的个数:
根据定义求
//计算公式：phi[n]=n*(1-1/p1)*(1-1/p2)*...*(1-1/pn)=n*(p1-1)/p1*(p2-1)/p2*...(pn-1)/pn
int get_phi(int n)
{
int res=n;
for(int i=2;i<=n/i;i++)
{
if(n%i==0)
{
res=res/i*(i-1);
while(n%i==0) n/=i;
}
}
if(n>1)
res=res/n*(n-1);
return res;
}
2. 筛法求1-n每个数的phi值（欧拉函数）
#include<iostream>
using namespace std;
const int N =1e6+5;
typedef long long ll;
bool isprime[N];
int prime[N];
int phi[N];
int cnt;
void euler()
{
phi[1]=1;
for(int i=2;i<=N;i++)
{
if(!isprime[i])
{
prime[cnt++]=i;
phi[i]=i-1;
}
for(int j=0;prime[j]<=N/i;j++)
{
int t=prime[j]*i;
isprime[t]=true;
if(i%prime[j]==0)
{
phi[t]=prime[j]*phi[i];break;
}
phi[t]=(prime[j]-1)*phi[i];
}
}
}
int main()
{
euler();
return 0;
}
六、组合数学
1. a, b 范围在2000以内，100000组询问，求c(a,b)%(1e9+7)的值。
题目链接：Acwing 885.求组合数1
询问次数很大，所以需要预处理出来2000以内的所有c(a,b)
这里用到了一个递推式：c(a, b)=c(a-1,b-1)+c(a-1,b)
从前a个数里面挑b个数，它比a-1多的就是第a个数，那么如果b个数里面包含第a个数，就从前a-1个数里面挑b-1个数，如果不包含，就从前a-1个数里面挑b个数。分别对应等式右边的两个值。
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int mod=1e9+7;
const int N =2005;
int c[N][N];
void init()
{
for(int a=0;a<=2000;a++)
{
for(int b=0;b<=a;b++)
{
if(b==0)
c[a][b]=1;
else
c[a][b]=(c[a-1][b-1]+c[a-1][b])%mod;
}
}
}
int main()
{
int n;
cin>>n;
init();
while(n--)
{
int a,b;
scanf("%d%d",&a,&b);
printf("%d\n",c[a][b]);
}
return 0;
}
2. a, b范围在1e5以内，100000组询问，求c(a,b)%(1e9+7)的值。
题目链接：Acwing 886. 求组合数2
由于询问数量同样很大，所以也需要进行预处理，只不过不是直接处理出c(a,b)的值。
这里用到了求组合数的定义式：
那么我们直接处理出1-N的阶乘就好。需要注意的是a / b != (a%mod) / (b%mod)
那么我们需要求出分母的逆元，那么需要处理出1-N阶乘的逆元。（由于mod是个质数，可以运用小费马定理求逆元）
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long ll;
const int N =1e5+10,mod=1e9+7;
ll fac[N],infac[N];
ll q_pow(ll a,ll b)
{
ll ans=1;
while(b)
{
if(b&1)
ans=ans*a%mod;
a=a*a%mod;
b>>=1;
}
return ans;
}
void init()
{
fac[0]=infac[0]=1;
for(int i=1;i<N-5;i++)
{
fac[i]=fac[i-1]*i%mod;
infac[i]=infac[i-1]*q_pow(i,mod-2)%mod;
}
}
int main()
{
init();
int n;
cin>>n;
while(n--)
{
int a,b;
scanf("%d%d",&a,&b);
printf("%lld\n",fac[a]*infac[a-b]%mod*infac[b]%mod);
}
return 0;
}
3. a, b在1e18范围内，p在1e5范围内，求c(a,b)%p的值。
由于a,b非常大，而模数比较小，所以我们可以运用lucas定理求解。
lucas定理的内容是：c(a,b)%p = c(a%p, b%p) * c(a/p, b/p) %p
需要注意的是，如果a,b均小于p，那么可以直接运用定义求解
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
typedef long long ll;
ll p;
ll q_pow(ll a,ll b)
{
ll ans=1;
while(b)
{
if(b&1)
ans=ans*a%p;
a=a*a%p;
b>>=1;
}
return ans;
}
ll C(ll a,ll b)
{
ll ans=1;
for(ll i=a,j=1;j<=b;i--,j++)
{
ans=ans*i%p;
ans=ans*q_pow(j,p-2)%p;
}
return ans;
}
ll lucas(ll a,ll b)
{
if(a<p&&b<p)
return C(a,b);
return C(a%p,b%p)*lucas(a/p,b/p)%p;
}
int main()
{
int n;
cin>>n;
while(n--)
{
ll a,b;
cin>>a>>b>>p;
cout<<lucas(a,b)<<endl;
}
return 0;
}
4. a, b在5000以内，输入a,b，求c(a,b)的值。
题目链接：Acwing 888. 求组合数4
题目没有要求让模某一个数字，那么就要输出一个很大很大的数字，需要用高精度进行运算。
但是直接进行高精度乘法和除法比较慢，而且很麻烦。于是我们用分解质因数的方法进行计算。
计算出每一个质因数在c(a,b)的分子中出现了多少次，分母中出现了多少次，两者相减，就是它对答案的贡献，最后用高精度乘法把它们乘起来就可以了。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int N = 5005;
int prime[N],isprime[N],sum[N],cnt;
void init(int n)
{
for(int i=2;i<=n;i++)
{
if(!isprime[i])
{
prime[cnt++]=i;
for(int j=i+i;j<=n;j+=i)
isprime[j]=1;
}
}
}
int get_p(int n,int p)
{
int ans=0;
while(n)
{
ans+=n/p;
n/=p;
}
return ans;
}
vector<int> mul(vector<int> &a,int b)
{
int t=0;
vector<int> ans;
for(int i=0;i<a.size();i++)
{
t+=a[i]*b;
ans.push_back(t%10);
t/=10;
}
while(t)
{
ans.push_back(t%10);
t/=10;
}
return ans;
}
int main()
{
int a,b;
cin>>a>>b;
init(a);
for(int i=0;i<cnt;i++)
{
int p=prime[i];
sum[i]=get_p(a,p)-get_p(a-b,p)-get_p(b,p);
}
vector<int> ans;
ans.push_back(1);
for(int i=0;i<cnt;i++)
{
for(int j=0;j<sum[i];j++)
ans=mul(ans,prime[i]);
}
for(int i=ans.size()-1;i>=0;i--)
cout<<ans[i];
return 0;
}
七、高斯消元
// a[N][N]是增广矩阵
int gauss()
{
int c, r;
for (c = 0, r = 0; c < n; c ++ )
{
int t = r;
for (int i = r; i < n; i ++ ) // 找到绝对值最大的行
if (fabs(a[i][c]) > fabs(a[t][c]))
t = i;
if (fabs(a[t][c]) < eps) continue;
for (int i = c; i <= n; i ++ ) swap(a[t][i], a[r][i]); // 将绝对值最大的行换到最顶端
for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c]; // 将当前上的首位变成1
for (int i = r + 1; i < n; i ++ ) // 用当前行将下面所有的列消成0
if (fabs(a[i][c]) > eps)
for (int j = n; j >= c; j -- )
a[i][j] -= a[r][j] * a[i][c];
r ++ ;
}
if (r < n)
{
for (int i = r; i < n; i ++ )
if (fabs(a[i][n]) > eps)
return 2; // 无解
return 1; // 有无穷多组解
}
for (int i = n - 1; i >= 0; i -- )
for (int j = i + 1; j < n; j ++ )
a[i][n] -= a[i][j] * a[j][n];
return 0; // 有唯一解
}
八、容斥原理
模板题： ACwing 能被整除的数
给定一个整数n和m个不同的质数p1,p2,…,pm。
请你求出1~n中能被p1,p2,…,pm中的至少一个数整除的整数有多少个。
输入格式
第一行包含整数n和m。
第二行包含m个质数。
输出格式
输出一个整数，表示满足条件的整数的个数。
数据范围
1≤m≤16,
1≤n,pi≤109
输入样例：
10 2
2 3
输出样例：
7
#include<iostream>
using namespace std;
typedef long long ll;
int a[20];
int main()
{
int n,m;
cin>>m>>n;
for(int i=0;i<n;i++)
cin>>a[i];
int ans=0;
for(int i=1;i<(1<<n);i++)
{
ll t=1,cnt=0;
for(int j=0;j<n;j++)
{
if(i>>j&1)
{
if(t*(ll)a[j]>m)
{
t=-1;break;
}
t*=a[j];cnt++;
}
}
if(t!=-1)
{
if(cnt%2)
ans+=m/t;
else
ans-=m/t;
}
}
cout<<ans<<endl;
return 0;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
