从头开始学数论（1）

从头开始学数论（1）

筛法

阶乘分解

题意是把一个数的阶乘通过分解质因数的方式分解出来并输出。

质因数分解自然要求质数， 对于本题直接用欧拉筛就可以了。

for (int i = 2; i <= n; i++) {
	if (!prime[i]) prime[++prime[0]] = i;
	for (int j = 1; j <= prime[0] && i * prime[j] <= n; j++) {
		prime[i * prime[j]] = 1;
		if (i % prime[j] == 0) break;
	}
}
for (int i = 1; i <= prime[0]; i++) {
	int t = prime[i], ans = 0;
	for (int j = n; j; j /= t) ans += j / t;
	printf("%d %d\n", t, ans);
}

无平方因子数

题目大意就是求一个区间里有多少个没有平方因子的数的个数。

虽然 $l$, $r$ 的大小大于了 $int$ 的范围， 但是 $r - l \le 10^ 7$ , 只用开 $10 ^ 7$ 的数组, 只考虑 $l$, $r$ 范围里的数。

类似的， 用模的方式把范围缩小到 $10 ^ 7$ 的规模， 用普通的筛就好了

inline ll getans(ll l, ll r) {
	ll ans = 0;
	for (int i = 2; i <= (sqrt)(r + 0.5); i++) 
		for (int j = l / i / i; j * i * i <= r; j++)
			if (j * i * i >= l) 
            	vis[j * i * i % (r - l + 1) + 1] = 1;
	for (int i = 1; i <= r - l + 1; i++) ans += (!vis[i]);
	return ans; 
}

「POJ2689」Prime Distance

题目大意

给出一个范围 $L, R$, 求这个范围里相邻质数的最大值和最小值。

分析

相邻质数用线性复杂度就可以解决，所以本题的难点是求质数。

直接预处理质数会导致时间复杂度爆炸， 用筛法优化空间复杂度又会爆炸。

我们可以假设用筛法， 如何优化空间复杂度？

可以想到不用求全部的质数， 因为$R-L\leq1000000$， 所以我们利用这 $10^6$ 的空间只处理 $R$, $L$ 以内的质数就可以了， 而用离散化的思路把空间复杂度再优化。

对于本题可以先预处理出 $\sqrt{n}$ 的质数， 再根据 $L$, $R$的范围处理这个范围里的质数， 暴力枚举最大值和最小值就好了。

还有一个需要特判，如果 $L$ 为1， 不会筛掉$1$， 加一个排除1的特判就好了。

for (int i = 2; i <= M; i++) {if (!vis[i]) {prime[++prime[0]] = i;for (int j = 1; j * i <= M; j++) vis[j * i] = 1;}}
while (~scanf("%d%d", &l, &r)) {
	memset(vis, 0, sizeof vis);
	for (int i = 1; i <= prime[0]; i++) 
		for (int j = l / prime[i]; j <= r / prime[i]; j++) 
			if (j > 1) vis[prime[i] * j - l] = 1;
	int siz = 0;
	if (l == 1) vis[0] = 0;
	for (int i = l; i <= r; i++) if (!vis[i - l]) ans[++siz] = i;
	int ans1 = INF, ans2 = -INF;
	int a, b, c, d;
	for (int i = 1; i < siz; i++) {
		if (ans[i] == 1) continue;
		int k = ans[i + 1] - ans[i];
		if (k < ans1) ans1 = k, b = ans[i + 1], a = ans[i];
		if (k > ans2) ans2 = k, d = ans[i + 1], c = ans[i];
	}
	if (ans1 == INF || ans2 == -INF) printf("There are no adjacent primes.\n");
	else printf("%d,%d are closest, %d,%d are most distant.\n", a, b, c, d);
}

「BZOJ1257」余数之和

题目就是要求
$ans = \sum_{i=1}^n {k\mod a_i}$

可以发现数据中可能会有 $k$ 小于 $a_i$ 的情况， 在这种情况下答案就是 $k$, 于是我们优雅的暴力就出来了。

cin >> n >> k;
if (n > k) ans += (ll)((n - k) * k), n = k; 
for (int i = 1; i <= n; i++) ans += (ll)(k % i);
cout << ans << endl;
	

在实际测试中这个代码可以得到 $81$ 的高分。

这个暴力的时间复杂度高的原因就是那个 $O(n)$ 的循环， 我们需要想办法优化这个循环。

用仅有的数论知识可以知道

$k \mod i = k - i * (k / i)$

所求就是

$\sum_{i =1} ^{n}k - i * (k / i) = k * n - \sum_{i = 1} ^ {n} i * (k / i)$

及现在要求的是

$$\sum_{i = 1} ^n i *(k / i)$$

若 $k / i = p$ 成立， 因为向下取整， 所以 $i$ 一定会有多个， 并且是单调递减的。

在实际表的过程中可以验证这个规律。

可以用分块的思想把这个数列分成多个块

同时对于每个块都有
$\sum_{i = 1} ^ ni * (k / i)= \sum_{i = 1} ^n i * \sum_{i = 1} ^ n (k / i)$

用 $l, r$ 表示这个块第一个和最后一个。

用代码和求和公式表示
$\sum_{i = 1} ^ n i * \sum_{i = 1} ^ n (k / i)$
即为

(k / i) * (l + r) * (r - l + 1) >> 1;

最后就是对 $l$, $r$ 的求解

假设 $r$已经求出， 用$l$ 表示下一个块就是 $r + 1$.

对于每个 $r$， 设 $x = \lfloor k / i\rfloor$（其中 $i < n$）, 由于向下取整， 所以 $x = \lfloor k / i\rfloor \leq k / i$ , 即 $x \le k / i$, 所以就有 $i \le k / x$， 即 $i \le k / (k / i)$。

在数轴上表示：

在这个解集中最右边的数是 $k / (k/l)$, 所以每个块的 $r$, 都是 $k / (k / l)$

又因为 $l \in n$， 和 $i$ 等价， $x$ 也为定值， 所以在代码实现中全部用 $l$, 代替 $i$。 也可以用任意 $\in n$ 的数来表示

cin >> n >> k;
if (n > k) ans += (ll)((n - k) * k), n = k; 
ans += k * n;
for (int l = 1, r = 0; l <= n; l = r + 1) {
	r = min(n, k / (k / l));
	ans -= (k / l) * (l + r) * (r - l + 1) >> 1; 
}
cout << ans << endl;

CF776B Sherlock and his girlfriend

思维题， 但是不难。

要求给不同数字分配一个颜色（另一个数字）， 如果一个数是另一个的质因数， 那颜色就不能染一样的， 要求最小化颜色数量并输出最后的方案。

考虑不同颜色之间 数的关系， 根据唯一分解的定理可知

$$a = x_1^{b_1} \times x_2^{b_2} \times \dots x_p^{b_p}$$

其中 $x$ 都是质数。

意思就是说任意一个数都可以分解成多个质数的乘积。

考虑合数一定可以被分解成别的质数的乘。

质数 $a$ 虽然也可以被分解成 $1 \times a$, 但是因为 1 不是质数 ， 且 $a$ 是它本身。

合数既然一定可以被分解， 质数一定不能被其他质数分解，要使颜色不同，那就可以合数一个颜色， 质数一个颜色。

保证了题目条件并且是最少的。

cin >> n; vis[0] = vis[1] = 1;
for (int i = 2; i <= N; i++) {
	if (!vis[i]) prime[++prime[0]] = i;
	for (int j = 1; j <= prime[0] && i * prime[j] <= N; j++) {
		vis[prime[j] * i] = 1;
		if (i % prime[j] == 0) break;
	}
}
n >= 3 ? cout << 2 << endl : cout << 1 << endl;
for (int i = 1; i <= n; i++)
	vis[i + 1] ? cout << "2 " : cout << "1 ";

「NOIP2009」Hankson 的趣味题

给出 $a_0, a_1, b_0, b_1$ 求下面的方程解的个数。

$$\left\{ \begin{array}{**lr**} \gcd(x, a_0) = a_1\\ lcm(x, b_0) = b_1\\ \end{array}\right.$$

可以考虑 $x$ 是 $b_1$ 的因数， 可以用 $O(b_1)$ 的时间枚举这个因数，在判断是否 合法。时间复杂度 $O(T b_1log_2b_1)$

显然这个做法只可以得到 50 分。

考虑因数基本都是成对出现的 ，可以用 $\sqrt{b_1}$ 的时间枚举它一半的因数，一次可以枚举两个 $i, b_1 / i$ 。时间复杂度 $O(T\sqrt{b1}log_2b1)$ ，就可以过了。

function <void()> solve = [&]() {
    int ans = 0;
    cin >> a0 >> a1 >> b0 >> b1;
    // 用 sqrt(b1) 的时间判断完因数。 
    for (int i = 1; i <= int(sqrt(b1)); i++) {
        // i 是否是 b1的因数 
        if (b1 % i) continue;
        ans += check(i) + (b1 / i != i && check(b1 / i)); 
    }
    cout << ans << endl;
};

欧拉函数

欧拉函数$φ(n)$ 是小于或等于 $n$ 的正整数中与 $n$ 互质的数的个数。

——如何求 ？ ——利用朴素或筛法

对于朴素还是推式子：

先列出欧拉函数的几个性质：

1. $φ(1) = 1$

2. 它是一个积性函数， 即 $φ(i) \times φ(k) = φ(i \times k)$

   证明: 设 $n$，$m$ 互质， 设 $m$ 有 $a_m$ 个因数， $n$ 有 $a_n$ 个因数：

   $φ(n) \timesφ(m)=n\times m\times \prod_{i=1}^{a_m}\frac{p_i - 1}{p_i} \times\prod_{i=1}^{a_n}\frac{p_i - 1}{p_i}=(n\times m) \times\prod_{i=1}^{a_m+a_n}\frac{p_i-1}{p_i}=φ(n\times m)$

3. 如果 $i$ 是质数， 就有 $φ(i) = i - 1$ 。因为质数和其他除自己之外的数都互质（定义认为 1也与 $i$ 互质）。

4. 如果 $i = p^k$ ($p$为质数，$k\ge1$) ，就有 $φ(p^k) = p^k - p^{k - 1}=p^k(1-p^{-1}) = p^k(1-\frac{1}{p})=\prod_{i=1}^k\frac{p_i - 1}{p_i}$, 对于 $φ(p^k)$ ，一共有 $p^k$ 个数可能被选为与 $p^k$ 互质的数，它们就是 1 到 $p^k$ 的所有数。可以想到，质数 $p$ 的倍数的数应有 $p^{k -1}$ 个，就是 $p\times1,p\times2,p\times3,\dots p\times p^{k - 1}$，减去这 $p^{k - 1}$ 个数就是这个欧拉函数的值，可以发现， 当 $k =1$ 时满足第 3 条性质， 当 $k=0$ 时满足第 1条性质。

设原数是 $n$， 通过唯一分解得 $n = {p_1}^{k_1} \times{p_2}^{k_2} \times \dots{p_m}^{k_m}$。

通过第二条性质 $φ(n)=φ({p_1}^{k_1})\timesφ({p_2}^{k_2})\dotsφ({p_m}^{k_m})$

通过第四条性质 $φ(n) = {p_1}^{k_1}\times{p_2}^{k_2}\dots{p_m}^{k_m}\times(1-\frac{1}{p_1})\times(1-\frac{1}{p_2})\dots\times(1-\frac{1}{p_m})$

通过唯一分解可得 $φ(n) = n \times(1-\frac{1}{p_1})\times(1-\frac{1}{p_2})\dots\times(1-\frac{1}{p_m})=n\times\prod_{i=1}^m\frac{p_i - 1}{p_i}$

上面的结果就是化简的最终结果。

using i64 = long long;
function <i64(i64)> oula = [&] (i64 x) {
    i64 t = x;
    for (i64 i = 2; i <= x / i; i++) if (x % i == 0) {
        t = t / i * (i - 1);
        while (x % i == 0) x /=i;
    }
    if (x > 1) t = t / x * (x - 1);
    return t;
};
 
while (true) {
    cin >> x;
    if (x == 0) return 0;
    cout << oula(x) << endl;
}

对于筛法：

设 $p$ 是 $n$ 的最小质因数， $n'=\frac{n}{p}$，那么 $n$ 就是通过 $n'$ 筛掉的。

再利用如下性质实现线性筛求欧拉函数。

• $i \mod x =0$： 其中第一步用朴素的式子替换欧拉函数

  $$φ(n) = n \times \prod_{i=1}^s\frac{p_i - 1}{p_i}=p_i\times n'\times\prod_{i=1}^s\frac{p_i - 1}{p_i}=p_i\timesφ(n')$$

• $i \mod x \neq0$。 那么： $φ(i \times k) = φ(i) \timesφ(k) = (i - 1) \timesφ(k)$

「BZOJ2818」gcd

求一对数 $x$, $y$， 要求：

• $1\le x,y\le n$
• $\gcd(x,y)$ 是素数

给出 $n$, 求满足条件的 $x$, $y$ 的对数。

化简一下第二个条件：

$\gcd(x, y) 是 \texttt{质数}$, 即 $\gcd(a \times p, b \times p) = p$, 其中 $x = a \times p, y = b \times p$, $p$是一个质数。

显然有 $a, b$ 互质。

如果有 $a$ 小于 $b$， 答案明显就是 $φ(b)$ 的值。

同时为了满足第一个条件， $a \times p \leq n, b \times p\leq n$ 就有 $a, b \le \frac{n}{p}$

综合一下答案， 就是 $\sum_{i = 1} ^ {\frac{n}{p}} φ(i)$ 。

显然，只用求 $φ(i)$ 本题就解决了。

ou[1] = 1;
	for (int i = 2; i <= n; i++) {
		if (!v[i]) {
			prime[++prime[0]] = i;
			ou[i] = i - 1;
		}
		for (int j = 1; j <= prime[0] && i * prime[j] <= n; j++) {
			v[i * prime[j]] = 1;
			if (i % prime[j] == 0) {ou[i * prime[j]] = ou[i] * prime[j];break;}
			if (i % prime[j] != 0) ou[i * prime[j]] = ou[i] * (prime[j] - 1);
		} 
	}
	for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + ou[i];
	for (int i = 1; i <= prime[0]; i++) ans += sum[n / prime[i]] * 2 - 1;
	printf("%lld\n", ans);

用前缀和优化，又因为数字对反过来也是一组解，所以要乘 2，还要减去 $1, 1$ 多记录的一次。

高斯消元

就是求多元一次方程组。

$$\begin{bmatrix} a_{1,1}x_1 + a_{1,2}x_2 +a_{1,3}x_3 \dots+a_{1,n}x_n = b_1 &\\ a_{2,1}x_1 + a_{2,2}x_2 +a_{2,3}x_3 \dots+a_{2,n}x_n = b_2 &\\ a_{3,1}x_1 + a_{3,2}x_2 +a_{3,3}x_3 \dots+a_{3,n}x_n = b_3 &\\ \end{bmatrix}$$

高斯消元可以得到 $x_1$ 到 $x_n$ 的答案

可以直记录方程组各个未知数的系数和等式右边的常数如下：

$$\begin{bmatrix} a_{1,1}, a_{1,2},a_{1,3} \dots,a_{1,n}, |b_1\\ a_{2,1}, a_{2,2},a_{2,3} \dots,a_{2,n}, |b_2 \\ a_{3,1}, a_{3,2},a_{3,3} \dots,a_{3,n}, |b_3 \\ \end{bmatrix}$$

大概就是这个形式。。。。左边的系数+右边的常数就是增广矩阵

高斯消元下面通过三种操作把方程简化成简化接替式矩阵。

• 把一行的数全部乘一个数 $a(a\neq0)$。
• 用一行减去另外一行。
• 将某两行的数交换。

最后应该把矩阵化简为下面这种形式， 这样才可以求解。

$$\begin{bmatrix} 1, 0, 0\dots0,0 = y_1\\ 0, 1, 0\dots0,0 = y_2\\ \dots\\ 0, 0, 0\dots0,1 = y_n\\ \end{bmatrix}$$

明显各个答案就是后面的常数 $y_1, y_2 \dots y_n$ 。

思考无解的情况：

• 没有解
• 有无数组解。

对于第一种情况，当系数为 0 时，常数不为零。

对于第二种情况， 消 $x$ 的元把 $y$ 消掉了，说明 $y$ 与原方程没有关系，$x$ 叫做主元， $y$ 叫做自由元。

对于代码

for (int i = 1; i <= n; i++) {
    int f = 1;
    int m = 0, id = 0;
    for (int j = i; j <= n; j++) 
        if (abs(a[j][i]) > m) f = 0, m = abs(a[j][i]), id = j;
    if (f) return printf("No Solution\n"), 0;
    for (int j = 1; j <= n + 1; j++) swap(a[i][j], a[id][j]);
    for (int j = 1; j <= n; j++) {
        if (i != j) {
            double b = a[j][i] / a[i][i];
            for (int k = i; k <= n + 1; k++)
                a[j][k] -= a[i][k] * b;
        }
    }
}
for (int i = 1; i <= n; i++) 
    printf("%.2f\n", a[i][n + 1] / a[i][i]);