筛素数(线性筛法)
1-n内大约有 n/ln(n)个素数。
int primes[N], cnt; // primes[]存储所有素数
bool st[N]; // st[x]存储x是否被筛掉
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 qmi(int m, int k, int p)
{
int res = 1 % p, t = m;
while (k)
{
if (k&1) res = res * t % p;
t = t * t % p;
k >>= 1;
}
return res;
}
求约数个数
假如去求1-n所有数约数的总和,不能一个一个求每个数的约数,时间复杂度较高,是O(n*sqrt(n))。我们可以求每一个数的倍数哪些,时间复杂度可以降到O(n*log(n))。
for(int i=1;i<=M;i++)
{
for(int j=i;j<=M;j+=i)
{
s[j]+=1; //s[j]存储j的约数个数
}
}
反素数
反素数指的是1-n的范围内约数最多的数(约数一样多,取较小者)。
反素数有如下几个性质:1、质因子在为2e9的范围内,最多只有9个。 2、每个质因子的次数最多不超过30。 3、质因子越小,次数越大。
因为一个数的质因子不多,故可以使用搜索求解。
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
int primes[] = {2,3,5,7,11,13,17,19,23};
int n,maxd,number;
void dfs(int u,int last,int p,int s) //p表示当前这个数多大,s代表当前约数的个数
{
if(s>maxd || s==maxd && p<number )
{
maxd = s;
number = p;
}
if(u==9) return;
for(int i=1;i<=last;i++)
{
if((LL)p*primes[u]>n) break;
p*=primes[u];
dfs(u+1,i,p,s*(i+1));
}
}
int main()
{
cin>>n;
dfs(0,30,1,1);
cout<<number;
return 0;
}
线性筛法求欧拉函数
phi[i] 表示小于i与i互质数的个数,需要注意的是,如果i是个质数,那么 phi[i] = i-1。
int phi[N],primes[N],st[N];
int cnt;
void init(int n)
{
for(int i=2;i<=n;i++)
{
if(!st[i])
{
primes[cnt++] = i;
phi[i] = i-1;
}
for(int j=0;primes[j]*i<=n;j++)
{
st[primes[j]*i] = true;
if(i%primes[j]==0)
{
phi[i * primes[j]] = phi[i] * primes[j];
break;
}
phi[i * primes[j]] = phi[i] * (primes[j] - 1);
}
}
}
费马小定理
如果a与p互质,那么a的p-1次方mod p =1,该定理可以求解某个数同余的逆元。即把除以某个数取模,转变为乘上某个数取模。多用在组合数计算中。
int fact[N],infact[N];
int qmi(int a,int b)
{
int res=1;
while(b)
{
if(b&1)
{
res=a*res%mod;
}
a=a*a%mod;
b>>=1;
}
return res;
}
int main()
{
fact[0]=infact[0]=1;
for(int i=1;i<N;i++)
{
fact[i] = fact[i-1]*i%mod;
infact[i] = infact[i-1]*qmi(i,mod-2)%mod;
}
}
卢卡斯定理(求解组合数)
当组合数的下标和上标较大时,就需要使用Lucas定理求解组合数,并且组合数必须取模一个p,p为质数。 0<=m,n<=1e18,0<p<1e5。
#include<iostream>
#define int long long
using namespace std;
const int N = 1e5 + 10;
int f[N], g[N];
int qmi(int a, int b, int p)
{
int res = 1;
while (b)
{
if (b & 1) res = res * a % p;
a = a * a % p;
b >>= 1;
}
return res;
}
int getc(int n, int m, int p)
{
return f[n] * g[m] * g[n - m]%p;
//f表示阶乘,g表示乘法逆元,需要用快速幂和费马小定理求解
}
int Lucas(int n, int m, int p)
{
if (m == 0) return 1;
return Lucas(n / p, m / p, p) * getc(n % p, m % p, p) % p;
}
int main()
{
int T;
cin >> T;
f[0] = g[0] = 1;
while (T--)
{
int n, m;
int p;
cin >> n >> m >> p;
for (int i = 1; i < N; i++)
{
f[i] = f[i - 1] * i % p;
g[i] = g[i - 1] * qmi(i, p - 2, p) % p;
}
cout << Lucas(n+m, m, p) << endl;
}
return 0;
}
裴蜀定理
扩展欧几里得算法
int exgcd(int a, int b, int& x, int& y)
{
if (b == 0)
{
x = 1, y = 0;
return a;
}
int x1, y1, d;
d = exgcd(b, a % b, x1, y1);
x = y1, y1 = x1 - a / b * y1;
return d;
}
假如最后要求得解是最小正整数,可以使用模加模的技巧,eg: (x%m+x)%m