数论模板及推理过程

一. 质数

1.试除法判定质数

一个数的因数都是成对出现的，我们可以判定较小的一个
需要注意的是尽量不要用i<=sqrt(x) or i*i <= x，一是为了减少运算，二是为了防止超出int范围

bool is_prime(int x)
{
	if (x < 2)return false;
	for (int i = 2; i <= n / i; i++)
		if (n % i == 0)return false;
	return true;
}

2.分解质因数

根据算数基本定理：每个正整数都能够以唯一的方式用其质因子的乘积表示
n=p1^a1 * p2^a2 * p3^a3…
有一个细节需要注意：n中最多包含一个大于sqrt(n)的因子，可以通过反证法证明，如果有两个大于sqrt(n)的因子，则相乘必然会大于n
例如 ：n=16, 16/2还是有2的倍数，所以循环晒去。最后n如果>1说明这就是大于sqrt(n)的唯一质因子。

void divide(int n)
{
	for (int i = 2; i <= n / i; i++)
	{
		if (n % i == 0)
		{
			int s = 0;//s表示次数
			while (n % i == 0)
			{
				n /= i;
				s++;
			}
			cout << i << ' ' << s << endl;
		}
	}
	if (n > 1)cout << n << ' ' << 1 << endl;
}

3.筛质数

(1)普通筛法 O(nlogn)

无论是素数还是合数都用来筛掉其后边的倍数

void get_primes(int n)
{
	for (int i = 2; i <= n; i++)
	{
		if (!st[i])primes[cnt++] = i;
		for (int j = i; j <= n; j += i)st[j] = true;
	}
}

(2)埃式筛法O(nloglogn)

Eratosthenes 筛法利用的原理是 任意整数 x 的倍数 2x，3x，… 等都不是质数 。
但是即便如此也会有重复标记的现象，例如12既会被2又会被3标记，在标记2的倍数时，12=6∗2，在标记3的倍数时，12=4∗3 ，根本原因是没有找到唯一产生12的方式。

void get_primes(int n)
{
	for (int i = 2; i <= n; i++)
	{
		if (!st[i])
		{
			primes[cnt++] = i;
			for (int j = i; j <= n; j += i)st[j] = true;
		}
	}
}

(3)线性筛法O(n)

n只会被他的最小质因子筛掉
如果i%primes[j]==0，则说明primes[j]是i的最小质因子，同时也是primes[j]*i的最小质因子，因此为了防止重复标记，break即可

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

4.哥德巴赫猜想

任意一个大于 4 的偶数都可以拆成两个奇素数之和。
直接筛素数枚举即可

		for (int i = 1;; i++)
		{
			int a = primes[i];
			int b = n - a;
			if (!st[b])
			{
				printf("%d = %d + %d\n", n, a, b);
				break;
			}
		}

5. 阶乘分解

例子：如果计算8！中2的个数

1 2 3 4 5 6 7 8
  1   1   1   1
      1       1
              1
 4 + 2 + 1 = 7

    for (int i = 0; i < cnt; i++)
    {
        int p = primes[i];
        int s = 0;
        for (int j = n; j; j /= p)s += j / p;
        cout << p << ' ' << s << endl;
    }

二. 快速幂

1. 快速幂模板：

int qmi(int a, int k)
{
    int res = 1;
    while (k)
    {
        if (k & 1)res = (LL)res * a % mod;
        a = (LL)a * a % mod;
        k >>= 1;
    }
    return res;
}

2. 费马小定理(快速幂求逆元)

三. 约数

1. 试除法求约数

成对筛

vector<int> get_divisors(int x)
{
    vector<int> res;
    for (int i = 1; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res.push_back(i);
            if (i != x / i) res.push_back(x / i);
        }
    sort(res.begin(), res.end());
    return res;
}

2. 约数个数

(1)约数个数模板

结论：n=p1^a1 * p2^a2 * p3^a3…
ans=(a1+1) * (a2+1) * (a3+1)....
每一个约数 d 可以表示为
d=p1^b1 * p2^b2 * p3^b3…
b1一共有 0 ~ a1种选法，b2有0 ~ a2种选法…
所以约数个数一共是(a1+1) * (a2+1) * (a3+1)…
求n!^2一共有多少个约数
(2c1+1)∗(2c2+1)∗…∗(2ck+1)

void divisor(int n)
{
	unordered_map<int, int> hash;
	for (int i = 2; i <= n / i; i++)
	{
		while (n % i == 0)
		{
			n /= i;
			hash[i]++;
		}
	}
	if (n > 1)hash[n]++;
	int res = 1;
	for (auto& x : hash)ans *= (x.second + 1) % mod;
	cout << res << endl;
}

(2)约数与倍数的巧妙转换

约数和倍数其实是一对好基友，当求约数的时间复杂度过大时，不妨从它倍数的角度来考虑解决问题
例子：对于每个Ai,在其他数中由多少个数是它的约数？
统计 Ai出现的次数

   for(int i = 0; i < n; i++) 
    {
        scanf("%d", &a[i]);
        cnt[a[i]]++;
    }
   for(int i = 1; i < N; i++)
    {
        if(!cnt[i]) continue;
        //i其实就是Ak，j就是i的倍数
        for(int j = i; j < N; j += i)
        {
            res[j] += cnt[i];
        }
    }
    最后对于每个res - 1(删除自己)

3. 约数之和

while (b – ) t = (t * a + 1) % mod;

t=t∗p+1
t=1
t=p+1
t=p^2+p+1
……
t=p^b + p^b-1…+1

void divisor(int n)
{
	unordered_map<int, int> hash;
	for (int i = 2; i <= n / i; i++)
	{
		while (n % i == 0)
		{
			n /= i;
			hash[i]++;
		}
	}
	if (n > 1)hash[n]++;
	int res = 1;
	for (auto x : hash)
	{
		long long t = 1;
		while (x.second--)t = (t * x.first + 1) % mod;
		res = res * t % mod;
	}
	cout << res << endl;
}

四. 欧拉函数

1. 求欧拉函数(容斥原理)

void Euler(int n)
{
	ll res = n;
	for (int i = 2; i <= n / i; i++)
	{
		if (n % i == 0)
		{
			while (n % i == 0)n /= i;
			res = res / i * (i - 1);
		}
	}
	if (n > 1)res = res / n * (n - 1);
	cout << res << endl;
}

2. 筛法求欧拉函数

void init(int n)
{
    phi[1] = 1;
	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);
		}
	}
}

五. 扩展欧几里得

1. 扩展欧几里得算法

给定n对正整数ai,bi，对于每对数，求出一组xi,yi，使其满足 aixi+biyi=gcd(ai,bi)。

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;
}

2. 线性同余方程

解线性同余方程的解

注意负数的取余运算

六. 矩阵乘法

1. 求斐波那契前N项

矩阵具有结合律，所以求 F[n]=F[1]∗A∗A∗…∗A=F[1]∗AnF[n]=F[1]∗A∗A∗…∗A=F[1]∗An ，利用快速幂，下面找出A的表达式

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 3;
int n, m;
void mul(int c[], int a[], int b[][N])//一维
{
	int temp[N] = { 0 };
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < N; j++)
		{
			temp[i] = (temp[i] + a[j] * b[j][i]) % m;
		}
	}
	memcpy(c, temp, sizeof temp);
}
void mul(int c[][N], int a[][N], int b[][N])//二维
{
	int temp[N][N] = { 0 };
	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
			for (int k = 0; k < N; k++)
				temp[i][j] = (temp[i][j] + a[i][k] * b[k][j]) % m;
	memcpy(c, temp, sizeof temp);
}
signed main()
{
	cin >> n >> m;
	int f1[N] = { 1,1,1 };
	int a[N][N] = { {0,1,0},{1,1,1},{0,0,1} };
	n--;
	while (n)
	{
		if (n & 1)mul(f1, f1, a);
		mul(a, a, a);
		n >>= 1;
	}
	cout << f1[2] << endl;
}