数学知识学习(持续更新)

阅读目录

Ⅰ 质数
Ⅱ 约数

本文与我的洛谷博客同步更新，在这里查看效果更佳。

数学知识学习(模板)

回到顶部

Ⅰ 质数

⒈ 试除法

⑴ 判定素数

时间复杂度： $\Theta(\sqrt{n})$

#include <bits/stdc++.h>
using namespace std;

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

int main()
{
	int n;
	cin >> n;
	while (n -- )
	{
		int x;
		cin >> x;
		if (isPrime(x))
			cout << "Yes" << endl;
		else
			cout << "No" << endl;
	}
	return 0;
}

⑵ 分解质因数

时间复杂度： $\Theta(\log n)$ 与 $\Theta(\sqrt{n})$ 之间

#include <bits/stdc++.h>
using namespace std;

void isPrime(int x)
{
	for (int i = 2; i <= x / i; i ++ )
	{
		if (x % i == 0)
		{
			int s = 0;
			while (x % i == 0)
				x /= i, ++s;
			cout << i << " " << s << "\n";
		}
	}
	if (x > 1)
		cout << x << " " << 1 << "\n";
	cout << "\n";
}

int main()
{
	int n;
	cin >> n;
	while (n -- )
	{
		int x;
		cin >> x;
		isPrime(x);
	}
	return 0;
}

⒉ 埃氏筛

原理：

将 $1$ ~ $n$ 排成一行，从第1个开始，在每个数上向后把这个数的倍数全部筛掉，这样就可以只剩下质数了。

时间复杂度： $\Theta(n\log \log n)$

附：一般， $\log \log n$ 会忽略不计，也就是说，时间复杂度近似 $\Theta(n)$ 。但是，真正能做到 $\Theta(n)$ 的算法是下一个算法——线性筛。

Code - 模板

int primes[N], cnt;
bool st[N];

void ass(int n)//埃氏筛模板
{
	for (int i = 2; i <= n; ++i)
	{
		if (!st[i])
		{
			primes[cnt++] = n;
			for (int j = i + i; j <= n; j += i)
				st[j] = true;
		}
	}
}

Code - 用法

int main()
{
	int n;
	cin >> n;
	ass(n);
	cout << cnt;
	return 0;
}

记

我们发现这里面似乎会对某些数标记了很多次其为合数。有没有什么办法省掉无意义的步骤呢？请看下一个算法！

⒊ 线性筛法（埃氏筛优化）

优化方式：

我们在上一个算法中提到埃氏筛会对某些数标记了很多次其为合数，如果能让每个合数都只被标记一次，那么时间复杂度就可以降到 $\Theta(n)$ 了。

时间复杂度： $\Theta(n)$

Code - 模板

const int N = 1000010;
int primes[N], cnt;
bool st[N];

void xxs(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;
		}
	}
}

Code - 用法

int main()
{
	int n;
	cin >> n;
	xxs(n);
	cout << cnt;
	return 0;
}

分析

对于代码 if(i%primes[j]==0)break;， $n$ 只会被最小的质因子筛掉。
证明如下：

这里，我们分两种情况来讨论。

i%primes[j]==0，则 primes[j] 一定是 i 的最小质因子，primes[j] 也一定是 primes[j]*i 的最小质因子。
i%primes[j]!=0，则 primes[j] 一定小于 i 的所有质因子，primes[j] 也一定是 primes[j]*i 的最小质因子。

证毕!

回到顶部

Ⅱ 约数

⒈ 试除法求约数

时间复杂度： $\Theta(\sqrt{n})$

Code - 模板

vector<int> get_divisors(int n)\\试除法求约数模板
{
	vector<int> res;
	for (int i = 1; i <= n / i; ++i)
	{
		if (n % i == 0)
		{
			res.push_back(i);
			if (i != n / i)
				res.push_back(n / i);
		}
	}
	sort(res.begin(), res.end());\\不必要时可以不加
	return res;
}

注意：这个模板求的约数是以 vector 的类型返回的，所以，在使用时，要小心。具体使用方法看下面的用法代码。

Code - 用法

int x;
cin >> x;
auto res = get_divisors(x);
for (auto t : res)
	cout << t << " ";

⒉ 约数个数与约数和专题

0 注

本小节的内容部分摘自这里

⑴ 基本定理

算术基本定理：设 $n={p_1}^{r_1}{p_2}^{r_2}{p_3}^{r_3}\cdots{p_k}^{r_k}$

约数个数公式： $d(n)=(r_1+1)\times(r_2+1)\times(r_3+1)\times\cdots\times(r_k+1)$

约数和公式： $\sigma(n)=\prod\limits_{i=1}^k\left(\sum\limits_{j=0}^{r_i}{p_i}^{j}\right)$

⑵ 求单个数的约数个数

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

/**
 * 功能：计算约数个数
 * @param n
 * @return
 */
LL getDivisorCount(LL x)
{
    unordered_map<int, int> primes; //key:质数 value:个数
    //求质数因子
    for (int i = 2; i <= x / i; i++)
        while (x % i == 0) x /= i, primes[i]++; //primes[i]表示质数i因子的个数+1
    //如果还有质数，那就加上
    if (x > 1) primes[x]++;
    //公式大法
    LL res = 1;
    for (auto p: primes) res = res * (p.second + 1);
    return res;
}

LL res;

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) cout << i << " " << getDivisorCount(i) << endl;
    return 0;
}

⑶ 求数字连乘积的约数个数

#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;

int main()
{
	int n;
	cin >> n;
	unordered_map<int, int> primes;
	while (n--)
	{
		int x;
		cin >> x;
		for (int i = 2; i <= x / i; ++i)
		{
			while (x % i == 0)
			{
				x /= i;
				++primes[i];
			}
		}
		if (x > 1)
			++primes[x];
	}
	long long res = 1;
	for (auto prime : primes)
		res = res * (prime.second + 1) % mod;
	cout << res;
}

⑷ 求单个数字的约数和

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
/**
 * 功能：计算约数之和
 * @param n
 * @return
 */
LL getSumOfDivisors(LL x)
{
    //拆出所有质数因子及质数因子个数
    unordered_map<int, int> primes;
    for (int i = 2; i <= x / i; i++)
        while (x % i == 0)
        {
            x /= i;
            primes[i]++;
        }
    if (x > 1) primes[x]++;
    //计算约数个数
    LL res = 1;
    for (auto p : primes)
    {
        LL a = p.first, b = p.second;
        LL t = 1;
        while (b--) t = (t * a + 1);
        res = res * t;
    }
    return res;
}
LL res;
int main()
{
    int n;
    cin >> n;
    cout<<getSumOfDivisors(n) << endl;
    return 0;
}

⑸ 求数字连乘积的约数和

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
unordered_map<int, int> primes;

int main()
{
	int n, x;
	cin >> n;
	while (n--)
	{
		cin >> x;
		for (int i = 2; i <= x / i; i++)
		{
			while (x % i == 0)
			{
				primes[i]++;
				x /= i;
			}
		}
		if (x > 1)
			primes[x]++;
	}
	ll res = 1;
	for (auto p : primes)
	{
		ll a = p.first, b = p.second;
		ll t = 1;
		while (b--)
			t = (t * a + 1) % mod;
		res = res * t % mod;
	}
	cout << res << endl;
	return 0;
}

⑹ 筛法求区间内的约数个数与约数和

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
/**
 * 功能：线性筛出约数个数与约数和
 * Tag:模板，约数个数，约数和
 */
const int N = 1e6 + 10;
int n;
int primes[N];      //质数数组
int idx;            //质数数组下标游标
bool st[N];         //是否已被筛出
int d[N];           //约数个数数组
int sigma[N];       //约数和数组
void get_divisor(int n)
{
    //积性函数的出发值
    d[1] = sigma[1] = 1;
    for (int i = 2; i <= n; i++)  //倍数
    {
        if (!st[i])primes[++idx] = i, d[i] = 2, sigma[i] = i + 1;
        for (int j = 1; i * primes[j] <= n & j <= idx; j++)
        {
            st[i * primes[j]] = true;
            d[i * primes[j]] = d[i] << 1;
            sigma[i * primes[j]] = sigma[i] * (primes[j] + 1);
            if (i % primes[j] == 0)
            {
                d[i * primes[j]] -= d[i / primes[j]];
                sigma[i * primes[j]] -= primes[j] * sigma[i / primes[j]];
                break;
            }
        }
    }
}
LL res;
int main()
{
    cin >> n;
    //开始筛约数个数，约数和
    get_divisor(n);
    //输出约数个数和
    for (int i = 1; i <= n; i++) res += d[i];
    cout << res << endl;
    return 0;
}

⑺辗转相除法求最大公约数

#include <bits/stdc++.h>
using namespace std;

int gcd(int a, int b)
{
	return b ? gcd(b, a % b) : a;
}

int main()
{
	int n;
	cin >> n;
	while (n -- )
	{
		int a, b;
		scanf("%d%d", &a, &b);
		printf("%d\n", gcd(a, b));
	}
	return 0;
}

⒊ 欧拉函数

定义

在数论，对正整数 $n$ ，欧拉函数是小于等于 $n$ 的正整数中与 $n$ 互质的数的数目。

定理

设 $n={p_1}^{r_1}{p_2}^{r_2}{p_3}^{r_3}\cdots{p_k}^{r_k}$

那么 $\varphi(n) = n\times\left(1 - \dfrac{1}{p_1}\right) \times \left(1 - \dfrac{1}{p_2}\right) \times\cdots\times\left(1 - \dfrac{1}{p_k}\right)$

Code - 求单个数的欧拉函数

#include <bits/stdc++.h>
using namespace std;

int main()
{
	int n;
	cin >> n;
	while (n--)
	{
		int a;
		cin >> a;
		int res = a;
		for (int i = 2; i <= a / i; ++i)
		{
			if (a % i == 0)
			{
				res = res / i * (i - 1);
				while (a % i == 0)
					a /= i;
			}
		}
		if (a > 1)
			res = res / a * (a - 1);
		cout << res << endl;
	}
	return 0;
}

求 $1$ 到 $n$ 的欧拉函数之和（欧拉筛）

分析

Code

#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, phi[N], prime[N], cnt;
bool st[N];

long long get_euler(int x)
{
	phi[1] = 1;
	for (int i = 2; i <= x; i++)
	{
		if (!st[i])
		{
			prime[cnt++] = i;
			phi[i] = i - 1;
		}
		for (int j = 0; prime[j] <= x / i; j++)
		{
			st[i * prime[j]] = true;
			if (i % prime[j] == 0)
			{
				phi[i * prime[j]] = prime[j] * phi[i];
				break;
			}
			else
				phi[i * prime[j]] = (prime[j] - 1) * phi[i];
		}
	}
	long long res = 0;
	for (int i = 1; i <= x; i++)
		res += phi[i];
	return res;
}

int main()
{
	cin >> n;
	cout << get_euler(n) << endl;
	return 0;
}

__EOF__

本文作者：绿树公司
本文链接：https://www.cnblogs.com/wp-lvshu/p/15802232.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2022-01-14 15:55 绿树公司阅读(55) 评论(2) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 数学知识学习(持续更新)（提高组）

· NOI / 2.1基本算法之枚举-8760:Cantor表

· 学习笔记——数论

· Acwing 第四章数学知识

· 基础数学数论问题

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· 阿里巴巴 QwQ-32B真的超越了 DeepSeek R-1吗？
· 【译】Visual Studio 中新的强大生产力特性
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 【设计模式】告别冗长if-else语句：使用策略模式优化代码结构

公告

数学知识学习(持续更新)

发表于 2022-01-14 15:55阅读：55评论：2推荐：1

学习数学学习

关注

跳至底部

Live2D

欢迎阅读『数学知识学习(持续更新)』

有问题找我哦，如果点击按钮失效，就直接向QQ：3052424159发送消息

点击黄色小点让小老鼠跑步，点击小老鼠周围即可喂食。

昵称：绿树公司
园龄： 3年1个月
粉丝： 1
关注： 0

+加关注

随笔分类

学习(3)

数学知识学习(模板)

Ⅰ 质数

⒈ 试除法

⑴ 判定素数

时间复杂度：Θ(√n)Θ(n)\Theta(\sqrt{n})

⑵ 分解质因数

时间复杂度：Θ(logn)Θ(log⁡n)\Theta(\log n)与Θ(√n)Θ(n)\Theta(\sqrt{n})之间

⒉ 埃氏筛

原理：

时间复杂度：Θ(nloglogn)Θ(nlog⁡log⁡n)\Theta(n\log \log n)

Code - 模板

Code - 用法

记

⒊ 线性筛法（埃氏筛优化）

优化方式：

时间复杂度：Θ(n)Θ(n)\Theta(n)

Code - 模板

Code - 用法

分析

Ⅱ 约数

⒈ 试除法求约数

时间复杂度：Θ(√n)Θ(n)\Theta(\sqrt{n})

Code - 模板

Code - 用法

⒉ 约数个数与约数和专题

0 注

⑴ 基本定理

⑵ 求单个数的约数个数

⑶ 求数字连乘积的约数个数

⑷ 求单个数字的约数和

⑸ 求数字连乘积的约数和

⑹ 筛法求区间内的约数个数与约数和

⑺辗转相除法求最大公约数

⒊ 欧拉函数

定义

定理

Code - 求单个数的欧拉函数

求 111 到 nnn 的欧拉函数之和（欧拉筛）

分析

Code

公告

绿树公司

数学知识学习(持续更新)

搜索

常用链接

最新随笔

随笔档案

时间复杂度： $\Theta(\sqrt{n})$

时间复杂度： $\Theta(\log n)$ 与 $\Theta(\sqrt{n})$ 之间

时间复杂度： $\Theta(n\log \log n)$

时间复杂度： $\Theta(n)$

时间复杂度： $\Theta(\sqrt{n})$

求 $1$ 到 $n$ 的欧拉函数之和（欧拉筛）