目录
一.数论
1.质数
在大于1 的整数,只包含1和本身这两个约数,则称为质数(素数) 2 3 5 7 11 13 17
(1)质数的判断
试除法(优化)枚举到根号x O(根号x)
bool is_prime(int x)
{
if (x < 2) return false;
for (int i = 2; i <= x / i; i ++ ) //以前是i<x
if (x % i == 0) //包含其他约数
return false;
return true;
}
(2)分解质因数(数=几个质数相乘)
void divide(int x)
{
for (int i = 2; i <= x / i; i ++ ) //x/i即sqrt复杂度
if (x % i == 0) //i一定是质数
{
int s = 0; //计数
while (x % i == 0) x /= i, s ++ ;
cout << i << ' ' << s << endl;
}
if (x > 1) cout << x << ' ' << 1 << endl;
cout << endl;
}
//eg
//x=6
// 2 1
// 3 1
//x=3
// 3 1 这里用到了x>1语句,因为直接跳出for循环x/i,只能另外判断
(3)求1-n的所有质数
埃式筛法O(nloglogn)
先用2去筛,即把2留下,把2的倍数剔除掉;再用下一个素数,也就是3筛,把3留下,把3的倍数剔除掉;接下去用下一个素数5筛,把5留下,把5的倍数剔除掉;不断重复下去…。
如图:
算法核心:把每个质数的所有倍数筛掉
int primes[N], cnt; // primes[]存储所有素数
bool st[N]; // st[x]存储x是否被筛掉 默认false
void get_primes(int n)
{
for (int i = 2; i <= n; i ++ )
{
if (st[i]) continue; //st如果是true 说明被筛过,那么它的倍数肯定被筛过,所以直接跳过
//接下来对该质数的所有倍数进行筛选
primes[cnt ++ ] = i;
for (int j = i + i; j <= n; j += i)
st[j] = true;
}
}
2.约数
什么是约数?
约数,又称因数。整数a除以整数b(b≠0),除得的商正好是整数而没有余数,我们就说a能被b整除,或b能整除a。a称为b的倍数,b称为a的约数。
(1)试除法求所有约数
暴力来解决这个问题很简单,就是从1开始遍历到n即可
for(int i = 1; i <= x; i++)
{
if(x % i == 0) res.push_back(i);
}
通过对质数的学习,我们知道一个数的因数即约数是成对出现的,所以我们同样可以用试除法,计算小的约数,并将大的约数添加到答案里,注意判断一下两者是否相同避免重复即可。
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);
}
给定 n 个正整数 ai,对于每个整数 ai,请你按照从小到大的顺序输出它的所有约数。
输入格式
第一行包含整数 n。
接下来 n 行,每行包含一个整数 ai。
输出格式
输出共 n 行,其中第 i 行输出第 i 个整数 ai 的所有约数。
数据范围
1≤n≤100,
2≤ai≤2×1e9
输入样例:
2
6
8
输出样例:
1 2 3 6
1 2 4 8
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int n;
int main()
{
cin>>n;
while(n--)
{
int x;
cin >> 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());
for (auto k : res) cout << k << ' ';
cout << endl;
}
return 0;
}
(2)约数个数和约数之和
如果一个数N分解质因数为 N = p1^c1 * p2^c2 * ... *pk^ck (p为质数)
约数个数: (c1 + 1) * (c2 + 1) * ... * (ck + 1)
example 36=2*2*3*3=2^2 * 3^2
36的约数为 2^0*3^0 2^0*3^1 2^0*3^2 2^1*3^0 2^1*3^1 …………2^2*3^2
只需改变质因数的个数,就会多一个约束
一共(2+1)(2+1)= 9种
代码实现的思路:
1、在每次输入一个数时,分解其质因数,将其出现的次数保存起来;
2、遍历保存质因数的表,将每个质因数出现的次数+1再相乘即可(即约数个数公式)。
#include<iostream>
#include<algorithm>
#include<unordered_map>
#include<vector>
using namespace std;
typedef long long LL;
const int N = 110, mod = 1e9+7;
int main(){
int n;
cin >> n;
unordered_map<int,int> primes;
// 每次将输入的数分解质因数,质因数放在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] ++ ; // 保存最后一个质因数
}
LL res = 1;
for(auto p : primes) res = res*(p.second+1) % mod;
cout << res << endl;
return 0;
}
约数之和: (p1^0 + p1^1 + ... + p1^c1) * ... * (pk^0 + pk^1 + ... + pk^ck)
对于约数个数那个式子,它所选取的括号里的每一个p也是不同的,即分解后的每一个乘积式子都可以看作一个数,这样我们就将所有约数的和求出了。
//约数之和,则只用改这个for循环即可
for (auto prime : primes)
{
LL p = prime.first, a = prime.second;
LL t = 1;
while (a--) t = (t * p + 1) % mod;
//还要算0次方,算0次方就直接加1了,然后从一次方算方便些
/*计算一下:
第一步:
t = (t * a + 1)
t=p1的一次方+p1的零次方;
第二步:
t = (t * a + 1)
t=p1的二次方+p1的一次方+1=p1的二次方+p1的一次方+p1的零次方;
*/
res = res * t % mod;
}
(3)最大公约数(欧几里得算法 )
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}