文章目录
1.质数：
质数的判定：
试除法：
bool is_prime(int n){
if(n<2) return false;
for(int i=2;i<n;i++)
if(n%i==0)
return false;
return true;
上面的时间复杂度为o(n)的吗，很暴力
我们对着上面的式子进行优化，结合质数的性质，质数都是成对出现的。所以我们只需要列出最小的一个就可以了
假设d为其中一个，n/d就是另外一个 d<n/d d<根号（n）
所以改成for(int i=2;i<sqrt(n);i++) 但是不推荐，因为sqrt很慢；
推荐 for(int i=2;i<=n/i;i++) //注意这儿是等于
分解质因数
试除法：从小到大列举我们的质因数
void divide(int n){
for(int i=2;i<=n;i++)
if(n%i==0){
int s=0;
while(n%i==0){
n/=i;
s++;
}
printf("%d %d\n",i,s);
}
}
以上的过程看视就是把我们的每一个数列举出来而不是质因数，但是这儿有一点就是我们
当列举到i的时候，已经把我们的2---i所有的数已经列举了，所以i一定是质数；
举个例子 当i=6 的时候，能够满足if(n%i==0)条件的n数一定都被i=2,3 磨干净了
----------------------------------
那么我们参考上面找质数的方法进行优化呢？ 参考性质 一个数最多含有一个大于qort(n)的质因数，证明用反证法；
所以：
void divide(int n){
for(int i=2;i<=n/i;i++)
if(n%i==0){
int s=0;
while(n%i==0){
n/=i;
s++;
}
printf("%d %d\n",i,s);
}
if(n>1) printf("%d %d\n",n,1); //我们将这个大于qort(n)的数放在了最后面来处理；
}
筛质数
朴素筛法：o(nlogn)
int primes[N], cnt; // primes[]存储所有素数
bool st[N]; // st[x]存储x是否被筛掉
void get_primes(int n)
{
for (int i = 2; i <= n; i ++ )000
{
if (!st[i]) primes[cnt ++ ] = i;
for (int j = i + i; j <= n; j += i) //为什么找一个数的倍数的标准做法
st[j] = true;
}
}
以上其实没有必要把每一个数的倍数都来筛一遍，我们只需要例举出质数的倍数就可以了
埃式筛法：o(nloglogn);
int primes[N], cnt; // primes[]存储所有素数
bool st[N]; // st[x]存储x是否被筛掉
void get_primes(int n)
{
for (int i = 2; i <= n; i ++ )
{
if (st[i]) continue;
primes[cnt ++ ] = n;
for (int j = i + i; j <= n; j += i)
st[j] = true;
}
}
线性筛法：o(n)
该方法的目标就是不是找出一个i就把所有的i的倍数全部排除掉，而是每次只把最以primes[j]最小的质数的数非排除掉;
int primes[N], cnt; // primes[]存储所有素数
bool st[N]; // st[x]存储x是否被筛掉
void get_primes(int n)
{
for (int i = 2; i <= n; i ++ )
{
if (!st[i]) primes[cnt ++ ] = i;
for (int j = 0; primes[j] <= n / i; j ++ )
//终止条件为 :当i为质数，那么一直到primes[j]==i:如果是合数，就是下面的break条件
{
st[primes[j] * i] = true;
if (i % primes[j] == 0) break;// primes[j]一定是i的最小质因子
}
}
}
首先明白在第二个循环当中，i一定是大于primes[j]的；
1. 当i为质数的时候，i就是primes中最大的质数。那么当所以primes[j]肯定是primes[j]*i最小的质数。
依次轮询就可以了。
2. 当i为合数的时候，前期和上面一样慢慢的轮询，等到i%primes[j]==0 的时候就必须要break了，不然
后面的primes[j] * i就是不正确的，因为 primes[j]*i 其实背后还有一个比primes[j]更小的质数。
也就是说primes[j]并不是 primes[j]*i 最小的质数，
3. 证明（我们假设i为合数，因为质数的时候很简单） ：
(1)当i%primes[j]!=0 的时候，由于我们prime是从从小往大取的，所以prime[j]一定是最小的质数（比i的最小质因数还小）
primes[j]肯定是primes[j]*i最小的质数。
(2)当i%primes[j]==0 的时候，prime[j]一定是i的最小质因数。所以也是primes[j]*i最小的质数。
约束
（1）试除法求一个数的所有约数
枚举两个约束中比较小的一个
vector<int> get_divisors(int x) O(sqrt(n));
{
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）约数的个数
（3）约束的之和
如果 N = p1^c1 * p2^c2 * ... *pk^ck
约数个数： (c1 + 1) * (c2 + 1) * ... * (ck + 1)
约数之和： (p1^0 + p1^1 + ... + p1^c1) * ... * (pk^0 + pk^1 + ... + pk^ck)
### 个数：
#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;
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;
-----------
### 求和：
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;
}
-----------
欧几里得算法 —求最大公约数—辗转相除法
定理：假设c为(a,b)的最大公约数 那么c也是（b,a%b)的最大公约束；
因为a%b== a-(a/b)*b ==a-k*b;
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}
-----------
欧拉函数
1-n中和n互质数的个数 （互质：只有公约数1的两个数） 也就是最大公约数为1-----（c,m)=1;
如果 N = p1^c1 * p2^c2 * ... *pk^ck
我们去掉1-n中所有p1,p2,...pk的倍数
-------------------------容斥原理----------------------------
|那么有多少个呢？N-N/p1-N/p2-N/p3....N/pk;这里面有多去的部分|
|加上所有pi*pj的倍数 +N/(Pi*pj)+... |
|减去所有pi*pj*pk的倍数 |
-------------------------------------------------------------
那么互质的个数=N*(1-1/p1)*(1-1/p2)*.....(1-1/pk); 时间复杂度瓶颈在分解质因数上面
---------------------------------------------------------------------------------
int phi(int x)
{
int res = x;
for (int i = 2; i <= x / i; i ++ )
if (x % i == 0)
{
res = res / i * (i - 1); //为什么不写成 res=res*(1-1/i) ??挺重要的，这样改写（避免产生小数）
while (x % i == 0) x /= i;
}
if (x > 1) res = res / x * (x - 1);
return res;
}
筛法的欧拉函数：求的是每一个数的欧拉函数（利用了线性的筛法进行推导的）
int primes[N], cnt; // primes[]存储所有素数
int euler[N]; // 存储每个数的欧拉函数
bool st[N]; // st[x]存储x是否被筛掉
void get_eulers(int n)
{
euler[1] = 1;
for (int i = 2; i <= n; i ++ )
{
if (!st[i])
{
primes[cnt ++ ] = i;
euler[i] = i - 1; //当是一个质数的时候，欧拉就是i-1
}
for (int j = 0; primes[j] <= n / i; j ++ )
{
int t = primes[j] * i;
st[t] = true;
if (i % primes[j] == 0)
{
euler[t] = euler[i] * primes[j];//==0的时候
break;
}
euler[t] = euler[i] * (primes[j] - 1);//！=0的时候
}
}
}
扫一扫
2836
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
