算法竞赛--数学知识

筛素数(线性筛法）

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