数学相关

线性筛素数

$O(nloglogn)$写法:用每个数筛去他的倍数

$O(n)$写法：利用每个合数都能被表示成一系列素数积

int prime[maxn], cnt;
int vis[maxn];
void solve(int n) {
	vis[0] = vis[1] = 1;
	for (int i = 2; i <= n; ++i) {
		if (!vis[i])
			prime[cnt++] = i;
		for (int j = 0; j < cnt && i * prime[j] <= n; ++j) {
			vis[i * prime[j]] = 1;
			if (i % prime[j] == 0)
				break;
		}
	}
}

欧拉定理

参考链接

若正整数a和n互质，则$a^{\phi (n)}\equiv 1(modn)$其中φ(n)为1～n中与n互质的数的个数

推论

若正整数a和n互质，对于任意正整数b，满足$a^b\equiv a^{bmod\phi (n)}(modn)$；可以用来对于求幂运算时缩小数据范围和计算次数；特别的若a和n不互质，则$a^b\equiv a^{bmod\phi (n)+\phi (n)}(modn)$

引理

对于任意互质的正整数a和n，满足$a^x\equiv 1(modn)$的最小整数$x$是$\phi (n)$的约数

根据欧拉函数定义$\varphi (n)=n\prod _{i=0}^s(1-\frac{1}{p_i})$，其中$p_i$是$n$的质因子

int euler_phi(int n) {
  int m = int(sqrt(n + 0.5));
  int ans = n;
  for (int i = 2; i <= m; i++)
    if (n % i == 0) {
      ans = ans / i * (i - 1);
      while (n % i == 0) n /= i;
    }
  if (n > 1) ans = ans / n * (n - 1);
  return ans;
}

费马小定理

对于质数p，任意整数a，均满足$a^p\equiv a(modp)$ ； 属于欧拉定理的特例

Miller_Rabin素数判断

1. 利用费马小定理，对数n，若它是素数，就满足$x^{n-1}\equiv 1(modn)$，我们随机几个数判断若出现结果不为1则可以判断不为素数
2. 二次检测，$n-1=r\ast 2^d$，依次检验$r\ast x^{d-1}modn$的结果若为1，则只能$x=1,x=n-1$，否则不为素数

typedef long long ll;
ll mod_mul(ll a, ll b, ll c) {
	ll rhs = 0;
	while (b) {
		if (b & 1)
			rhs = (rhs + a) % c;
		b >>= 1;
		a = (a + a) % c;
	}
	return rhs;
}
ll mod_exp(ll a, ll b, ll c) {
	ll rhs = 1;
	while (b) {
		if (b & 1)
			rhs = rhs * a % c;
		b >>= 1;
		a = a * a % c;
	}
	return rhs;
}

bool Miller_Rabin(ll n, int respat) {
	if (n == 2ll || n == 3ll || n == 5ll || n == 7ll || n == 11ll)
		return true;
	if (n == 1 || !(n % 2) || !(n % 3) || !(n % 5) || !(n % 7) || !(n % 11))
		return false;

	int k = 0;
	ll d = n - 1;
	while (!(d & 1ll)) {
		k++; d >>= 1ll;
	}
	srand((ll)time(0));
	for (int i = 0; i < respat; ++i) {
		ll a = rand() % (n - 2) + 2;
		ll x = mod_exp(a, d, n);
		ll y = 0ll;
		//二次探测，利用x^2≡1(modn)时只有x=1或x=n-1两个解
		for (int j = 0; j < k; ++j) {
			y = mod_mul(x, x, n);
			if (1ll == y && 1ll != x && n - 1ll != x)
				return false;
			x = y;
		}
		if (1ll != y)
			return false;
	}
	return true;
}

int main() {
	ll x; scanf("%lld", &x);
	if (Miller_Rabin(x, 6))
		printf("Yes\n");
	else
		printf("No\n");
}

线性同余方程

$ax\equiv b(modm)$，转换为$ax+my=b$，使用$exgcd$求解，注意有多解

1. 对于$ax+my=b$的有整数解的充分条件是$b(\mathrm{m}\mathrm{o}\mathrm{d}gcd(a,m))=0$
2. 对于$x_0,y_0$是原式的一组解，则其他解可由$x=x_0+b\ast t/gcd(a,m)$求解
3. 若$d=gcd(a,m)$，则方程在$[0,m/d-1]$上有唯一解

typedef long long ll;
ll exgcd(ll a, ll b, ll &x, ll &y) {
	if(b == 0) {
		x = 1;
		y = 0;
		return a;
	}
	ll r = exgcd(b, a % b, x, y);
	ll tmp = x;
	x = y;
	y = tmp - a / b * y;
	return r;
}
//ax = b(mod n) -> ax - ny = b
vector line_mod_quation(ll a, ll b, ll n) {
    ll x, y;
    ll d = exgcd(a, n, x, y);
    vector ans;
    ans.clear();
    if(b % d == 0) {
        x %= n; x += n; x %= n;
        ans.push_back(x * (b / d) % (n / d));
        for(int i = 1; i <= d; i++) ans.push_back((ans[0] + i *  n / d) % n);
    }
    return ans;
}

CRT

解决一元线性同余方程$x\equiv a_i(mod{m}_i)$，其中$m_i$是两两互质的数

1. 令$M=\prod_{i=1}^n{m_i}$，$Mi={\frac{M}{m_i}}$，$t_i$是$M_i*t_i≡1(modm_i)$的一个解

2. 那么x有整数解，为$x={\prod }_{i=1}^n{a}_i\ast M_i\ast t_i$ x为一个特解，通解可以用$x+km(k\in Z)$表示，最小整数解为$x\mathrm{m}\mathrm{o}\mathrm{d}m$

/*
x = a1(mod m1)
x = a2(mod m2)
.
x = an(mod mn)
其中m1到mn两两互质的整数
*/
ll exgcd(ll a, ll b, ll &x, ll &y) {
	if(b == 0) {
		x = 1;
		y = 0;
		return a;
	}
	ll r = exgcd(b, a % b, x, y);
	ll tmp = x;
	x = y;
	y = tmp - a / b * y;
	return r;
}
ll CRT(int n, int a[], int m[]) {
    ll M = 1, x = 0, xx, yy;
    for(int i = 0; i < n; i++) M *= m[i];
    for(int i = 0; i < n; i++) {
        ll w = M / m[i];
        exgcd(m[i], w, xx, yy);
        x = (x + yy * w * a[i]) % M;
    }
    return (x + M) % M;
}

exCRT

使用与$m_i$不为互质的一元线性同余方程组

1. 考虑合并$\{\begin{array}{l}x\equiv a_1(mod{m}_1)\\ x\equiv a_2(mod{m}_2)\end{array}$得到$\{\begin{array}{l}x\equiv a_1+m_1{y}_1\\ x\equiv a_2+m_2{y}_2\end{array}$也即是$m_1{y}_1+m_2{y}_2=a_2-a_1$
2. 使用$exgcd$解去一组可行解$(x1,y1)$，带回去计算出关于x的可行解$x_1$，则$x\equiv x_1(modm)$，其中$m=lcm(m_1,m_2)$

ll ex_gcd(ll a, ll b, ll& x, ll& y) {
  if (a == 0 && b == 0) return -1;  // 无最大公因数
  ll d = a;
  if (b != 0)
    d = ex_gcd(b, a % b, y, x), y -= x * (a / b);
  else
    x = 1, y = 0;
  return d;
}

// mod不满足两两互质
// 通解为 re + k*M
// 返回最小非负整数解
bool excrt(ll r[], ll m[], int n, ll& re, ll& M) {
  ll x, y;
  M = m[0], re = r[0];
  for (int i = 1; i < n; i++) {
    ll d = ex_gcd(M, m[i], x, y);
    if ((r[i] - re) % d != 0) return 0;
    x = (r[i] - re) / d * x % (m[i] / d);
    re += x * M;
    M = M / d * m[i];
    re = re % M;
  }
  re = (re + M) % M;
  return 1;
}

二次剩余

定义式子$x^2\equiv n(modp)$，给出n和p，是否存在一个式子满足该式子，即模p意义下的开根$\sqrt{n}$参考链接

1. 钱德勒Legender符号$(\frac{a}{p})=\{\begin{array}{l}1，a在模p意义是二次剩余\\ -1，a在模p意义下非二次剩余\\ 0，a\equiv 0(modp)\end{array}$
2. $(\frac{a}{p})\equiv a^{\frac{p-1}{2}}\mathrm{m}\mathrm{o}\mathrm{d}p$
3. 设a是满足$w\equiv a^2-n$是模p的非二次剩余，即$x^2\equiv w(modp)$无解，那么$x\equiv (a+\sqrt{w}{)}^{\frac{p+1}{2}}$是二次同余方程$x^2\equiv n\mathrm{m}\mathrm{o}\mathrm{d}p$的解

#define random(a,b) (rand()%(b-a+1)+a)
ll quickmod(ll a, ll b, ll c) {
	ll ans = 1;
	while (b) {
		if (b & 1)
			ans = ans * a % c;
		b >>= 1;
		a = a * a % c;
	}
	return ans;
}

ll p, w;
struct QuadraticField
{
	ll x, y;
	QuadraticField operator *(QuadraticField T) {
		QuadraticField rhs;
		rhs.x = (this->x * T.x % p + this->y * T.y % p * w % p) % p;
		rhs.x = (rhs.x + p) % p;
		rhs.y = (this->x * T.y % p + this->y * T.x % p) % p;
		rhs.y = (rhs.y + p) % p;
		return rhs;
	}
	QuadraticField operator ^(ll b) {
		QuadraticField rhs;
		QuadraticField a = *this;
		rhs.x = 1; rhs.y = 0;
		while (b) {
			if (b & 1)
				rhs = rhs * a;
			b >>= 1;
			a = a * a;
		}
		return rhs;
	}
};
ll Legender(ll a) {
	ll rhs = quickmod(a, (p - 1) / 2, p);
	if (rhs + 1 == p)
		return -1;
	else
		return rhs;
}
ll get_w(ll n, ll a) {
	return ((a * a % p - n) % p + p) % p;
}
ll solve(ll n) {
	ll a;
	if (p == 2)
		return n;
	if (Legender(n) == -1)
		return -1;
	srand((unsigned)time(NULL));
	while (true) {
		a = random(0, p - 1);
		w = get_w(n, a);
		if (Legender(w) == -1)
			break;
	}
	QuadraticField ans, rhs;
	rhs.x = a; rhs.y = 1;
	ans = rhs ^ ((p + 1) / 2);
	return ans.x;
}
int main()
{
	int t; scanf("%d", &t);
	while (t--) {
		ll n; scanf("%lld%lld", &n, &p);
		n %= p;
		if (n == 0)
			printf("0\n");
		else {
			ll ans1 = solve(n), ans2;
			if (ans1 == -1)
				printf("Hola!\n");
			else {
				ans2 = p - ans1;
				if (ans1 == ans2)
					printf("%lld\n", ans1);
				else
					printf("%lld %lld\n", min(ans1, ans2), max(ans1, ans2));
			}
		}
	}
}

原根

$(a,p)=1$时，满足$a^g\equiv 1(modp)$的最小的$g$正好等于$\phi (p)$

1. 对$p-1$进行质因子分解得到不同的质因子$d1,d2,...,dm$
2. 对任意$1<a<p$，只需要检验每个质因子$a^{\frac{p-1}{d_i}}$这m个数中是否存在模p意义下与1同余，则a不是p的原根；否则不是

int powmod(int a, int b, int p) {
	int res = 1;
	while (b) {
		if (b & 1)
			res = res * a % p;
		b >>= 1;
		a = a * a % p;
	}
	return res;
}
//找原根
int generator(int p) {
	vector fact;
	int phi = p - 1, n = phi;
	for (int i = 2; i * i <= n; ++i) {
		if (n % i == 0) {
			fact.push_back(i);
			while (n % i == 0)
				n /= i;
		}
	}
	if (n > 1)
		fact.push_back(n);
	for (int res = 2; res <= p; ++res) {
		bool ok = true;
		for (int factor : fact) {
			if (powmod(res, phi / factor, p) == 1) {
				ok = false;
				break;
			}
		}
		if (ok)
			return res;
	}
	return -1;
}

BSGS离散对数

关于$a^x\equiv b(modp)$的求解

1. 令$x=km-t$，其中$m=\sqrt{p}$，则原式为$a^{km-t}\equiv b(modp)，a^{km}\equiv b{a}^t(modp)$
2. 枚举$k,t<=m$，计算$a^{km}$并记录，再计算$b{a}^t$检查是否已经存在
3. 带入$x=km-t$

int sq = (int)sqrt(p + .0) + 1;
vector> dec(sq);
for (int i = 1; i <= sq; ++i)
	dec[i - 1] = { powmod(a, i * sq * k % (p - 1), p), i };
sort(dec.begin(), dec.end());
int any_ans = -1;
for (int i = 0; i < sq; ++i) {
	int my = powmod(a, i * k % (p - 1), n) * b % n;
	auto it = lower_bound(dec.begin(), dec.end(), make_pair(my, 0));
	if (it != dec.end() && it->first == my) {
		any_ans = it->second * sq - i;
		break;
	}
}

计算$x^k\equiv a(modn)$

1. 根据原根性质，找出$b$的原根$g$
2. 则令$x=g^c$，$x^k\equiv a\mathrm{m}\mathrm{o}\mathrm{d}p\to (g^k{)}^c\equiv a\mathrm{m}\mathrm{o}\mathrm{d}p$，即上面一种形式
3. 使用上面解法得出$c$的特解，则通解为$x\equiv g^{c+i\ast \frac{n-1}{gcd(n-1,k)}}$
   证明过程

int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
int powmod(int a, int b, int p) {
	int res = 1;
	while (b) {
		if (b & 1)
			res = res * a % p;
		b >>= 1;
		a = a * a % p;
	}
	return res;
}
//找原根
int generator(int p) {
	vector fact;
	int phi = p - 1, n = phi;
	for (int i = 2; i * i <= n; ++i) {
		if (n % i == 0) {
			fact.push_back(i);
			while (n % i == 0)
				n /= i;
		}
	}
	if (n > 1)
		fact.push_back(n);
	for (int res = 2; res <= p; ++res) {
		bool ok = true;
		for (int factor : fact) {
			if (powmod(res, phi / factor, p) == 1) {
				ok = false;
				break;
			}
		}
		if (ok)
			return res;
	}
	return -1;
}
//求x^k=a(modn)的所有解
int main()
{
	int n, k, a; scanf("%d%d%d", &n, &k, &a);
	if (a == 0)
		return puts("1\n0"), 0;
	int g = generator(n);
	int sq = (int)sqrt(n + .0) + 1;
	vector> dec(sq);
	for (int i = 1; i <= sq; ++i)
		dec[i - 1] = { powmod(g, i * sq * k % (n - 1), n), i };
	sort(dec.begin(), dec.end());
	int any_ans = -1;
	for (int i = 0; i < sq; ++i) {
		int my = powmod(g, i * k % (n - 1), n) * a % n;
		auto it = lower_bound(dec.begin(), dec.end(), make_pair(my, 0));
		if (it != dec.end() && it->first == my) {
			any_ans = it->second * sq - i;
			break;
		}
	}
	if (any_ans == -1)
		return puts("0"), 0;
	int delta = (n - 1) / gcd(k, n - 1);
	vector ans;
	for (int cur = any_ans % delta; cur < n - 1; cur += delta) 
		ans.push_back(powmod(g, cur, n));
	sort(ans.begin(), ans.end());
	printf("%d\n", ans.size());
	for (int answer : ans)
		printf("%d ", answer);
}

Ramsey定理

在人数为6的人群中，一定有三个人彼此相识，或者彼此不认识 => 对6个顶点的完全图的边用红，蓝两色着色，结果至少有两个同色的三角形

设a，b为正整数，令$N(a,b)$使保证有a个人彼此相识或者有b个人彼此不相识所需要的最小人数，则称$N(a,b)$为Ramsey数，满足$\{\begin{array}{l}N(a,b)=N(b,a)\\ N(a,2)=a\\ N(a,b)\le N(a-1,b)+N(a,b-1)\\ 特别的当N(a-1,b)和N(a,b-1)都为偶数时，\\ N(a,b)\le N(a-1,b)+N(a,b-1)-1\end{array}$

莫比乌斯反演

由容斥系数所构成的函数，莫比乌斯函数$\mu (d)=\{\begin{array}{l}1,d=1\\ (-1{)}^k,d=p_1{p}_2...p_k\\ 0,其他\end{array}$

性质

1. 对于任意正整数n，${\sum }_{d|n}\mu (d)=[n==1]$
2. 对于任意正整数n，${\sum }_{d|n}\frac{\mu (d)}{d}=\frac{\varphi (n)}{n}$

两个反演形式

1. $g(n)={\sum }_{d|n}f(d)$得到$f(n)={\sum }_{d|n}\mu (d)g(\frac{n}{d})$，因子关系
2. $g(n)={\sum }_{n|d}f(d)$得到$f(n)={\sum }_{n|d}\mu (\frac{d}{n})g(d)$，倍数关系

迪利克雷卷积

满足$(f\ast g)(n)={\sum }_{d|n}f(d)\ast g(\frac{n}{d})$；其中满足互质的整数$a,b,f(ab)=f(a)f(b)$的称为积性函数；满足任意正整数$a,b,f(ab)=f(a)f(b)$成为完全积性函数

常见的积性函数

$\{\begin{array}{l}\mu (n)，莫比乌斯函数\\ \varphi (n)，欧拉函数\\ d(n)，约数个数d(n)={\sum }_{d|n}1\\ \sigma (n)，约数和\sigma (n)={\sum }_{d|n}d\end{array}$

完全积性函数

$\{\begin{array}{l}ϵ(n)=[n==1]，元函数\\ I(n)=1，恒等函数\\ id(n)=n，单元函数\end{array}$

迪利克雷卷积性质

1. $f\ast g=g\ast f$，交换律
2. $((f\ast g)\ast h)=(f\ast (g\ast h))$，结合律
3. $((f+g)\ast h)=f\ast h+g\ast h$，分配律

常用等式

1. $\mu \ast I=ϵ$，${\sum }_{d|n}\mu (d)=[n==1]$
2. $\varphi \ast I=id$，${\sum }_{d|n}\varphi (d)=n$
3. $id\ast \mu =\varphi$，${\sum }_{d|n}\mu (d)\frac{n}{d}=\varphi$，欧拉函数定义

例题

求所有由a~z组成的长度为n的字符串中，没有周期性的字符串数量。重复性是指一个长度为n的字符串可以由一个长度为m$\frac{n}{m}$次得到，$2<=n<=10^9$

设$f(n)$为周期为n的因子的字符串的数量，每个位置有26个字母的选择，所以数量为$26^n$；设$g(n)$为周期为n的字符串的数量；则$f(n)={\sum }_{m|n}g(m)$
根据莫比乌斯反演，得到$g(n)={\sum }_{d|n}f(\frac{n}{d})\mu (d)={\sum }_{d|n}26^{\frac{n}{d}}\mu (d)$
因为n很大，无法打出全部的$\mu$值；根据$\mu$的定义，我们质因数分解$n$，枚举质因子处理出所有的因子的$\mu$值
注意$n<=10^9$的约数个数最大值也只有800左右

const int mod = 10009;
int mod_pow(int a, int b) {
	int res = 1;
	while (b) {
		if (b & 1) res = res * a % mod;
		b >>= 1;
		a = a * a % mod;
	}
	return res;
}
map moebius(int n) {
	map res;
	vector primes;

	for (int i = 2; i * i <= n; ++i) {
		if (n % i == 0) {
			primes.push_back(i);
			while (n % i == 0) n /= i;
		}
	}
	if (n != 1) primes.push_back(n);

	int m = primes.size();
	for (int i = 0; i < (1 << m); ++i) {
		int mu = 1, d = 1;
		for (int j = 0; j < m; ++j) {
			if (i >> j & 1) {
				mu *= -1;
				d *= primes[j];
			}
		}
		res[d] = mu;
	}
	return res;
}
int main()
{
	ios::sync_with_stdio(false); cin.tie(0);
	int n; cin >> n;

	int res = 0;
	map mu = moebius(n);
	for (auto it = mu.begin(); it != mu.end(); ++it) {
		res += it->second * mod_pow(26, n / it->first);
		res = (res + mod) % mod;
	}
	cout << res << '\n';
}

杜教筛

处理前缀和问题，只适用于积性函数，其中两个积性函数的积也为积性函数

常用推导过程

计算${\sum }_{i=1}^{n}f(i)$

• 令$h=f\ast g$，求${\sum }_{i=1}^{n}h(i)$
• 记$S(n)={\sum }_{i=1}^{n}f(i)$
• ${\sum }_{i=1}^{n}h(i)={\sum }_{i=1}^n{\sum }_{d|i}g(d)f(\frac{i}{d})={\sum }_{d=1}^{n}g(d)\ast {\sum }_{i=1}^{\frac{n}{d}}f(i)$
• 即${\sum }_{i=1}^{n}h(i)={\sum }_{d=1}^{n}g(d)\ast S(\frac{n}{d})$
• 将右边等式的第一项提出来得到${\sum }_{i=1}^{n}h(i)=g(1)S(n)+{\sum }_{d=2}^{n}g(d)\ast S(\frac{n}{d})$，移项$g(1)S(n)={\sum }_{i=1}^{n}h(i)-{\sum }_{d=2}^{n}g(d)S(\frac{n}{d})$

若$h(i)$很容易求出，那么只需要对后面$S(\frac{n}{d})$除法分块，复杂度为$O(n^{\frac{2}{3}})$

几个简单例子

$S(n)={\sum }_{i=1}^n\mu (i)$

根据$\mu \ast I=ϵ$，则$h=ϵ，f=\mu ，g=I$
则$S(n)=1-{\sum }_{i=1}^{n}S(\frac{n}{d})$

$S(n)={\sum }_{i=1}^n\varphi (i)$

根据$\varphi \ast I=id$
$S(n)={\sum }_{i=1}^{n}i-{\sum }_{d=2}^{n}S(\frac{n}{d})$

const int maxn = 1e6 + 5;
int phi[maxn], mu[maxn], vis[maxn];
int sum_mu[maxn], sum_phi[maxn];
vector prime;
unordered_map phi_mp;
unordered_map mu_mp;
void get(int n) {
	phi[1] = mu[1] = 1;
	for (int i = 2; i <= n; ++i) {
		if (!vis[i]) {
			prime.push_back(i);
			phi[i] = i - 1; mu[i] = -1;
		}
		for (int j = 0; j < prime.size() && prime[j] * i <= n; ++j) {
			vis[i * prime[j]] = 1;
			if (i % prime[j] == 0) {
				phi[i * prime[j]] = phi[i] * prime[j];
				mu[i * prime[j]] = 0;
				break;
			}
			else {
				mu[i * prime[j]] = -mu[i];
				phi[i * prime[j]] = phi[i] * (prime[j] - 1);
			}
		}
	}
	for (int i = 1; i <= n; ++i) {
		sum_mu[i] = sum_mu[i - 1] + mu[i];
		sum_phi[i] = sum_phi[i - 1] + phi[i];
	}
}
int djs_mu(int x) {
	if (x <= 1e6)
		return sum_mu[x];
	if (mu_mp.count(x))
		return mu_mp[x];
	int ans = 1;
	for (int l = 2, r; l >= 0 && l <= x; l = r + 1) {
		r = x / (x / l);
		ans -= (r - l + 1) * djs_mu(x / l);
	}
	return mu_mp[x] = ans;
}
long long djs_phi(long long x) {
	if (x <= 1e6)
		return sum_phi[x];
	if (phi_mp.count(x))
		return phi_mp[x];

	long long ans = x * (x + 1) / 2;
	for (long long l = 2, r; l >= 0 && l <= x; l = r + 1) {
		r = x / (x / l);
		ans -= (r - l + 1) * djs_phi(x / l);
	}
	return phi_mp[x] = ans;
}

$S(n)={\sum }_{i=1}^{n}i\ast \varphi (i)$

此时$f=i\ast \varphi (i)$，使用迪利克雷卷积打开$f\ast g={\sum }_{d|n}d\ast \varphi (d)\ast g(\frac{n}{d})$
令$g=id$，则${\sum }_{d|n}d\ast \varphi (d)\ast \frac{n}{d}={\sum }_{d|n}\varphi (d)\ast n=n^2$
$S(n)={\sum }_{i=1}^n{i}^2-{\sum }_{d=2}^{n}d\ast S(\frac{n}{d})$

总结：首先筛出数据范围根号内的积性函数的前缀后，再递归实现杜教筛，使用unodered_map减少复杂度

线性求逆元

设$t=\frac{P}{i}，k=P\%I$
对于$t\ast i+k\equiv 0\mathrm{m}\mathrm{o}\mathrm{d}P$，等式同除$i\ast k$
得到$\frac{t}{k}+\frac{1}{i}\equiv 0\mathrm{m}\mathrm{o}\mathrm{d}P$，即$t\ast inv[k]+inv[i]\equiv 0\mathrm{m}\mathrm{o}\mathrm{d}P$
代入$t,k$，则$inv[i]=(P-\frac{P}{i})\ast inv[P\%i]\%P$

int inv[maxn];
inv[1] = inv[2] = 1;
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;

哥德巴赫猜想

任何大于4的偶数都能表示为两个质数的和

奇数$n$只能表示为$2$和$n-2$两个质数；否则可以表示为偶数$(n-3)$和质数$3$，就是$3$个质数的和

Polya定理

解决等价类计数问题，等价关系即满足等价关系的两个元素，还满足自反性、对称性以及传递性。统计等价类的个数：使用置换集合F来描述，如果一个置换将一个方案映射到了另一个方案，说明两者是等价的。
Burnside定理：如果一个方案s经过一个置换f后不变，则称s为不动点，将f的所有不动点数目记为c(f)，那么等价类数目等于所有置换的c(f)的平均值。
典型的等价类置换：背景都是由n个珠子构成的环，并且颜色总数为t

1. 旋转
   如果旋转i颗珠子的间距，那么共有$gcd(i,n)$个循环，所以不动点的总数为$a=t^{gcd(0,n)}+t^{gcd(1,n)}+...+t^{gcd(n-1,n}$
2. 翻转
   分为奇偶情况：奇数时，对称轴有n条，每一条形成$\frac{n+1}{2}$个循环，所以不动点的总数为$b=n\ast t^{\frac{n+1}{2}}$
   偶数时，穿过珠子的对称轴有$\frac{n}{2}$条，每一条都形成$\frac{n}{2}+1$个循环，不穿过珠子的对称轴有$\frac{n}{2}$，每一条都形成$\frac{n}{2}$个循环。所以不动点的总数为$b=\frac{n}{2}\ast (t^{\frac{n}{2}+1}+t^{\frac{n}{2}}$
   最后，根据polya定理，只具有旋转性质的等价类有$\frac{a}{n}$种，只具有翻转性质的有$\frac{b}{n}$，两张都具有有$\frac{a+b}{2n}$

例题

n个石头排成一圈，要用m种颜色去染，求有多少种不同的染色方案。旋转之后相同的方案视为一种。输出方案数模$1000000007$，$n,m<=10^9$

考虑每种旋转，从旋转0位置、1位置到n-1位置的n种转法。
对计算旋转k位置后与原来相同的方案数，可知$i$位置的石头颜色要与$(i+kt)modn$的颜色相同，最小的$t=\frac{n}{gcd(k,n)}$满足条件
与第i个石头相同的石头的集合称为i的轨迹。显然，i的轨迹和(i+k)的轨迹是完全相同的。我们将n个石头划分为若干个互不相干的轨迹。而旋转之后和原来颜色相同的染色方案就是每一条轨迹都染同一个颜色。因此算出轨迹数目就可以知道有多少方案数旋转之后和原来相同了。
每一个轨迹石头的个数是$t=\frac{n}{gcd(k,n)}$，由于不同轨迹中石头数相同，则轨迹数为$\frac{n}{t}=gcd(k,n)$。因此旋转k个位置后与原来相同的方案数就是$m^{gcd(k,n)}$
计算答案时不断枚举k的值，并把$m^{gcd(k,n)}$的值加起来
优化：由于$gcd(k,n)$只有有限个不同的值，所以相同的值放在一起合并统计。设d为n的约数，即要统计满足$gcd(k,n)=d$的k的个数，而$k=d\ast t$。则$d=gcd(k,n)=gcd(d\ast t,n)=d\ast gcd(t,\frac{n}{d})$，因此$gcd(t,\frac{n}{d})=1$，满足条件的t的个数就是$\varphi (\frac{n}{d})$
则答案为$\frac{{\sum }_{d|n}{m}^d\varphi (\frac{n}{d})}{n}$

const int mod = 1e9 + 7;
int n, m;
void solve() {
	//质因子分解
	map primes = primes_factor(n);
	//约数
	vector divs = divsor(n);
	ll res = 0;
	for (int i = 0; i < divs.size(); ++i) {
		ll euler = divs[i];
		for (auto it = primes.begin(); it != primes.end(); ++it) {
			int p = it->first;
			if (divs[i] % p == 0) euler = euler / p * (p - 1);
		}

		res += euler * mod_pow(m, n / divs[i]) % mod;
		res %= mod;
	}

	printf("%lld\n", res * mod_pow(n, mod - 2) % mod);
}

阶乘有关

阶乘中某个质因子的个数

求出$n!$中质因子$x$的个数，例如求出15当中5的个数？

$15!=1\times 2\times \cdots \times 15$，其中5这个质因子只有在5的倍数中出现，即5、10、15当中$\frac{15}{5}$个，除以5又得1、2、3，由于不考虑非5的倍数，继而考虑它的子问题$3!$即可。

int get_prime_factor(int n, int x) {
    if (!n) return 0;
    return n / x + get_prime_factor(n / x, x);
}

求出$n!$最后的非0位

比如我们需要求出$10!$最后的非0位，由于质因数2和5组合会在结尾产生0.那么我们将$10!$中2、5质因数全部去掉（注意考虑多余的2对末位的影响）。如$1\times 2\times 3\times 4\times 5\times 6\times 7\times 8\times 9\times 10$去掉因子2和5后就是$1\times 1\times 3\times 1\times 1\times 3\times 7\times 1\times 9\times 1$，剩下的数字末尾一定是3、7、9、1之一，再考虑多余的2的贡献即可

对于如何求出剩下的一串数字相乘后末位的数字的求法，转化为求出这些数末位为3、7、9出现的次数（由于这些数的次方以4为周期，例如$3^0=1,3^1=3,3^2=9,3^3=7,3^4=1$），因此只需要求出这串数字末位3、7、9各自出现的次数。

一个数列实际可以分为奇数列和偶数列，以$10!=1\times 2\times \cdots \times 10$为例，分为$13579$和$246810$，可以发现实际上$246810$中的个数就是$12345$中的个数，也就是我们需要解决它的子问题:$f(n)=f(n/2)+g(n)$，$g(n)$表示奇数列中的数目

观察$g(n)$：$135791113\dots$实际上也分为$13791113\dots$以及5的奇数倍$51525\dots$部分，除以5又得到$1357\dots$子问题；因此统计末位为$x\in \{1,3,7,9\}$的个数即为$g(n,x)=n/10+(n\%10\ge x)+g(n/5,x)$

通过两个递归方程可以$lg(n)$的复杂度解出末位为1、3、7、9的个数。通过循环节的性质可以快速求解这串数字$\mathrm{m}\mathrm{o}\mathrm{d}10$的结果。

int g(int n, int x) {
    if (!n) return 0;
    return n / 10 + (n % 10 >= x) + g(n / 5, x);
}
int f(int n, int x) {
    if (!n) return 0;
    return f(n / 2, x) + g(n, x);
}
//2,3,7,9的循环节，其中注意若2的个数为0的话循环节第一位应该为1
int cyclic_section[][4] = {{6, 2, 4, 8}, {1, 3, 9, 7}, {1, 7, 9, 3}, {1, 9, 1, 9}};
int main() {
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        int cnt2 = get_prime_factor(n, 2) - get_prime_factor(n - m, 2);
        int cnt5 = get_prime_factor(n, 5) - get_prime_factor(n - m, 5);
        int cnt3 = f(n, 3) - f(n - m, 3);
        int cnt7 = f(n, 7) - f(n - m, 7);
        int cnt9 = f(n, 9) - f(n - m, 9);
        int ans = 1;
        if (cnt5 > cnt2) {
            printf("5\n"); continue;
        }
        if (cnt2 != cnt5) {
            ans *= cyclic_section[0][(cnt2 - cnt5) % 4];
            ans %= 10;
        }
        ans *= cyclic_section[1][cnt3 % 4]; ans %= 10;
        ans *= cyclic_section[2][cnt7 % 4]; ans %= 10;
        ans *= cyclic_section[3][cnt9 % 4]; ans %= 10;
        printf("%d\n", ans);
    }
}

伯努利数

伯努利数$B_n$是一个与数论有密切关联的有理数序列。前几项被发现的伯努利数分别是$B_0=1，B_1=1/2,B_2=1/6,B_3=0,B_4=-1/30,B_5=0,B_6=1/42,B_7=0,B_8=-1/30$

等幂求和

$S_m(n)={\sum }_{k=1}^n{k}^m=1^m+2^m+\cdots +n^m$

这个数列和必定为变量为$n$，次数为$m+1$的多项式，称为伯努利多项式。伯努利多项式的系数与伯努利数有着密切关系，如$S_m(n)=\frac{1}{m+1}{\sum }_{k=0}^m\left(\genfrac{}{}{0ex}{}{m+1}{k}\right)B_k{n}^{m+1-k}$

推导公式

${\sum }_{j=0}^m\left(\genfrac{}{}{0ex}{}{m+1}{j}\right)B_j=0$，初始$B_0=1$

代码

关于使用伯努利数来解决等幂求和的问题，给出问题的$m$，求出以$S_m(n)=\frac{1}{M}(a_{k+1}{n}^{k+1}+a_k{n}^k+\cdots +a_{1}n+a_0)$多项式表达的$M$以及系数$a_i$

用伯努利多项式系数推导公式计算出每项系数，在求出各个系数的分母的最小公倍数既是$M$，其他系数除以$M$既是$a_i$

typedef long long ll;
const int maxn = 20 + 3;
ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}
ll lcm(ll a, ll b) {
    ll ret = a / gcd(a, b) * b;
    return ret ? ret : -ret;
}
struct fraction {
    ll a, b;
    fraction() {}
    fraction(ll x) { a = x; b = 1; }
    fraction(ll x, ll y) { a = x; b = y; }

    void deal() {
        if (b < 0) b = -b, a = -a;
        ll k = gcd(a, b);
        if (k < 0) k = -k;
        a /= k; b /= k;
    }
    fraction operator +(const fraction& rhs) const {
        fraction ans;
        ans.b = lcm(b, rhs.b);
        ans.a = ans.b / b * a + ans.b / rhs.b * rhs.a;
        ans.deal();
        return ans;
    }
    fraction operator -(const fraction& rhs) const {
        fraction ans;
        ans.b = lcm(b, rhs.b);
        ans.a = ans.b / b * a - ans.b / rhs.b * rhs.a;
        ans.deal();
        return ans;
    }
    fraction operator *(const fraction& rhs) const {
        fraction ans;
        ans.a = a * rhs.a;
        ans.b = b * rhs.b;
        ans.deal();
        return ans;
    }
    fraction operator /(const fraction& rhs) const {
        fraction ans;
        ans.a = a * rhs.b;
        ans.b = b * rhs.a;
        ans.deal();
        return ans;
    }
    void println() {
        printf("%lld/%lld\n", a, b);
    }
};
fraction B[maxn];
ll C[maxn][maxn];
void init() {
    for (int i = 1; i < maxn; ++i) {
        C[i][0] = C[i][i] = 1;
        for (int j = 1; j < i; ++j) {
            C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
        }
    }
    B[0] = fraction(1);
    for (int i = 1; i <= 20; ++i) {
        B[i] = fraction(0);
        for (int j = 0; j < i; ++j)
            B[i] = B[i] - fraction(C[i + 1][j]) * B[j];
        B[i] = B[i] / fraction(C[i + 1][i]);
    }
}
int n; fraction a[maxn];
int main() {
    init();
    while (~scanf("%d", &n)) {
        ll Lcm = 1;
        for (int i = 0; i <= n; ++i) {
            a[i] = fraction(C[n + 1][i]) * B[i] * fraction(1, n + 1);
            Lcm = lcm(Lcm, a[i].b);
        }
        printf("%lld ", Lcm);
        a[1] = a[1] + fraction(1);
        for (int i = 0; i <= n; ++i)
            printf("%lld ", Lcm / a[i].b * a[i].a);
        puts("0");
    }
}

差分与牛顿级数

差分

将原函数$f(x)$映射到$f(x+1)-f(x+b)$。

函数的前向差分称为函数的差分，对于函数$f(x)$，如果在等距节点$x_k=x_0+kh,(k=0,1,\dots ,n),\Delta f(x_k)=f(x_{k+1})-f(x_k)$，则称$\Delta f(x)$为函数在每个小区间上的增量$y_{k+1}-y_k$为$f(x)$的一阶差分。

差分的阶

一阶差分的差分为二阶差分，依此类推。记${\Delta }^n[f](x)$为$f(x)$的$n$阶差分

若${\Delta }^n[f](x)=\Delta \{{\Delta }^{n-1}[f](x)\}={\Delta }^{n-1}[f](x+1)-{\Delta }^{n-1}[f](x)$

根据数学归纳法，可得${\Delta }^n[f](x)=\sum _{i=0}^n\left(\genfrac{}{}{0ex}{}{n}{i}\right)(-1{)}^{n-i}f(x+i)$，例如${\Delta }^2[f](x)=f(x+2)-2f(x+1)+f(x)$

差分的性质

• 若C为常数，则$\Delta C=0$
• 线性：如果a和b为常数，则有$\Delta (af+bg)=a\Delta f+b\Delta g$
• 乘法定则：$\Delta (fg)=f\Delta g+g\Delta f+\Delta f\Delta g$
• 级数：$\sum _{n=a}^b\Delta f(n)=f(b+1)-f(a)$

牛顿级数

牛顿插值公式也叫做牛顿级数，由“牛顿前向差分方程”的项组成

单位步长情况

当$x$值间隔为单位步长为1时，有

$\begin{array}{rl}f(x)& =f(a)+\frac{x-a}{1}\left[{\Delta }^1[f](a)+\frac{x-a-1}{2}({\Delta }^2[f](a)+\dots )\right]\\ & =f(a)+\sum _{k=1}^n{\Delta }^k[f](a)\prod _{i=1}^k\frac{[(x-a)-i+1]}{i}\\ & =\sum _{k=0}^n\left(\genfrac{}{}{0ex}{}{x-a}{k}\right){\Delta }^k[f](a)\end{array}$

这成立于任何多项式函数

例子

x	${\Delta }^0$	${\Delta }^1$	${\Delta }^2$	${\Delta }^3$
1	$\underline{1}$
		$\underline{3}$
2	4		$\underline{2}$
		5		$\underline{0}$
3	9		2
		7
4	16

$\begin{array}{rl}f(x)& ={\Delta }^0+{\Delta }^1\frac{(x-x_0)}{1!}+{\Delta }^2\frac{(x-x_0)(x-x_0-1)}{2!}(x_0=1)\\ & =1+3\cdot \frac{x-1}{1}+2\cdot \frac{(x-1)(x-2)}{2}\\ & =1+3(x-1)+(x-1)(x-2)\\ & =x^2\end{array}$

差分序列

序列满足第一项为$h[0][1]h[0][2]h[0][3]\dots$，且满足$h[i][j]=h[i-1][j+1]-h[i-1][j]$

若差分表第一行是多项式$f(x),f(x+1),\dots$，且多项式系数为$p$，则满足以下性质：

• 差分表$n+1$行都为0，第$n$行为一个常数
• 序列的一般表达式$f(n)=\sum _{i=0}^p\left(\genfrac{}{}{0ex}{}{n}{i}\right)h[0][i],n\in Z^{+}$，参考牛顿级数
• 前缀和$\sum _{i=0}^{n}f(i)=\sum _{i=0}^p\left(\genfrac{}{}{0ex}{}{n+1}{i+1}\right)h[0][i],n\in Z^{+}$

例子

p\n	0	1	2	3
0	$0^3$	$1^3$	$2^3$	$3^3$
1	1	7	19
2	6	12
3	6

则计算前$n=3$项和：$\begin{array}{rl}\sum _{i=0}^{3}f(i)& =\sum _{i=0}^3\left(\genfrac{}{}{0ex}{}{4}{i+1}\right)h[0][i]\\ & =\left(\genfrac{}{}{0ex}{}{4}{1}\right)0+\left(\genfrac{}{}{0ex}{}{4}{2}\right)1+\left(\genfrac{}{}{0ex}{}{4}{3}\right)6+\left(\genfrac{}{}{0ex}{}{4}{4}\right)6\\ & =6+24+6=36\end{array}$

计算第$n=4$项，$\begin{array}{rl}f(4)& =\sum _{i=0}^3\left(\genfrac{}{}{0ex}{}{3}{i}\right)h[0][i]\\ & =\left(\genfrac{}{}{0ex}{}{4}{0}\right)0+\left(\genfrac{}{}{0ex}{}{4}{1}\right)1+\left(\genfrac{}{}{0ex}{}{4}{2}\right)6+\left(\genfrac{}{}{0ex}{}{4}{3}\right)6\\ & =64=4^3\end{array}$

代码

给出n和m，求$\sum _{i=1}^n{i}^m$

直接套前缀和模板，计算出差分表与$C_{n+1}^i,i\in \{0\to m\}$

import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;
public class Main{
	Scanner scan = new Scanner(System.in);
	BigInteger c[]=new BigInteger[110];
	BigInteger h[][] = new BigInteger[110][110];
 
	void getc(BigInteger n, int m) {
		c[1] = n;
		for (int i = 2; i <= m+1; i++)
			c[i] = c[i - 1].multiply(n.subtract(BigInteger.valueOf(i - 1)))
					.divide(BigInteger.valueOf(i));
	}
	 PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));
	void run() {
		int cas=scan.nextInt();
		while(cas-->0){
		BigInteger n =scan.nextBigInteger().add(BigInteger.ONE);
		int m = scan.nextInt();
		for (int i = 0; i <= m; i++)
			h[0][i] = BigInteger.valueOf(i).pow(m);
		for (int i = 1; i <= m; i++)
			for (int j = 0; j <= m - i; j++)
				h[i][j] = h[i - 1][j + 1].subtract(h[i - 1][j]);
		BigInteger ans = BigInteger.ZERO;
		getc(n, m);
		for (int i = 0; i <= m; i++)
			ans=ans.add(h[i][0].multiply(c[i+1]));
		out.println(ans);
		out.flush();
		}
	}
 
	public static void main(String[] args) {
		new Main().run();
	}
}