标签：1.1 int 质数 枚举 ai 因子 数学知识 primes

一、简述

本文章主要介绍有关质数的基础算法。

二、质数

• 质数和合数是针对所有大于1的自然数来定义的，小于等于1的整数既不是质数也不是合数。
• 质数的因子只有1和它本身。

三、质数的判定——试除法

设一个数 n，因为质数的因子只有1和它本身，我们可以使用枚举从2 ~ n-1的方式，判断其中的数是否为 n 的因子，若存在 n 的因子，则不是质数，否则是质数。这样算法的时间复杂度是 O(n)。

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

不过，如果对于一个数 n，若存在 d | n(d 整除 n)，则 \(\frac{d}{n}\) | n，基于此，我们可以对上面的算法进行优化，使得时间复杂度降到 O(\(\sqrt{n}\))。

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

模板题AcWing866.试除法判定质数

题目描述

给定 n 个正整数 a_i，判定每个数是否是质数。

输入格式

第一行包含整数 n。
接下来 n 行，每行包含一个正整数 a_i。

输出格式

共 n 行，其中第 i 行输出第 i 个正整数 a_i 是否为质数，是则输出Yes，否则输出No。

数据范围

1≤ n ≤100，1≤ a_i ≤2³¹−1。

输入样例

2
2
6

输出样例

Yes
No

解题思路

试除法。

C++代码

#include <bits/stdc++.h>
using namespace std;
const int N = 110;

int n;

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

int main()
{
    scanf("%d", &n);
    for(int i = 0; i < n; i ++)
    {
        int x;
        scanf("%d", &x);
        if(isPrime(x)) puts("Yes");
        else puts("No");
    }
    return 0;
}

四、分解质因数——试除法

• 任何一个大于1的自然数 ，如果 N 不为质数，都可以唯一分解成有限个质数的乘积。
  N = \(P{^{a^1}_1}\)\(P{^{a^2}_2}\)\(P{^{a^3}_3}\)⋅⋅⋅\(P{^{a^n}_n}\)，这里 P₁ < P₂ < ⋅⋅⋅ < P_n 且均为质数，其指数均是正整数。
• 一个数 N 最多只有一个因子大于 \(\sqrt{N}\)(证明：反证法。假设有两个，则两个的乘积大于 N)。
• 试除法的时间复杂度为 O(\(\sqrt{n}\))；最好时间复杂度为 O(logn)，所有因子均为2。

void divide(int x)
{
    for(int i = 2; i <= x / i; i ++)
    {
        if(x % i == 0)
        {
            int s = 0;//统计质因子个数
            while(x % i == 0)
            {
                x /= i;
                s ++;
            }
            printf("%d %d\n", i, s);
        }
    }
    if(x > 1) printf("%d 1\n", x);
    printf("\n");
}

对于 x 的任意一个合数因子假设为 y，在枚举到它之前就已经将它从 x 中除去，因为 y 的质因子必是 x 的质因子，而这些质因子早已被枚举并除掉了。当枚举到某一个数 i 的时候，x的因子里面已经不包含[2，i−1]里面的数。

模板题AcWing867.分解质因数

题目描述

给定 n 个正整数 a_i，将每个数分解质因数，并按照质因数从小到大的顺序输出每个质因数的底数和指数。

输入格式

第一行包含整数 n。
接下来 n 行，每行包含一个正整数 a_i。

输出格式

对于每个正整数 a_i，按照从小到大的顺序输出其分解质因数后，每个质因数的底数和指数，每个底数和指数占一行。
每个正整数的质因数全部输出完毕后，输出一个空行。

数据范围

1≤ n ≤100，2≤ a_i ≤2×10⁹。

输入样例

2
6
8

输出样例

2 1
3 1

2 3

解题思路

试除法。

C++代码

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

int n;

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

int main()
{
    scanf("%d", &n);
    for(int i = 0; i < n; i ++)
    {
        int x;
        scanf("%d", &x);
        divide(x);
    }
    return 0;
}

五、质数筛

朴素筛

• 举例：比如我们要筛出1~16里的所有质数。
  初始数据：2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
  • 枚举2的倍数，则4、6、8、10、12、14、16被筛掉。
    剩余数据：2 3 5 7 9 11 13 15
  • 枚举3的倍数，则6、9、12、15被筛掉。
    剩余数据：2 3 5 7 11 13
  • 以此类推，最后剩余的数据2、3、5、7、11、13都是质数。因为我们枚举到 i 时，2到 i-1中一定不含 i 的因子，否则它早就被筛掉了。
• 时间复杂度分析：枚举2的倍数 O(\(\frac{n}{2}\))，枚举3的倍数 O(\(\frac{n}{3}\))，...，枚举 n 的倍数 O(1)。调和级数 1/2 + 1/3 + 1/4 + 1/5 + ... + 1/n=lnn + c(c 是欧拉常数，约等于0.577)。而 lnn < logn，故时间复杂度为 O(nlogn)。

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(st[i]) continue;//筛掉了
        primes[cnt ++] = i;
        for(int j = i + i; j <= n; j += i)//枚举倍数
            st[j] = true;
    }
}

埃氏筛

观察上述的朴素筛，我们可以发现，我们在枚举是，有许多数被重复筛掉了，因此我们希望只将质数的倍数筛掉即可。

• 质数定理：1~n 中有 \(\frac{n}{lnn}\) 个质数。
• 时间复杂度 O(nlog(logn))。

void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(!st[i])//质数
        {
            primes[cnt ++] = i;
            for(int j = i + i; j <= n; j += i)
                st[j] = true;
        }
    }
}

线性筛

• 核心思路：每个数都只会被它的最小质因子筛掉。
• 1～n 之间的任何一个合数一定会被筛掉，而且筛的时候只用最小质因子来筛，然后每一个数都只有一个最小质因子，因此每个数都只会被筛一次，因此线性筛法是线性的。

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 ++)
        {
            st[primes[j] * i] = true;
            if(i % primes[j] == 0) break;
        }
    }
}

• 关于 i % primes[j]
  • i % primes[j] == 0，则说明 primes[j] 一定是 i 的最小质因子( j 是从0开始枚举的)，则 primes[j] 一定是 primes[j] * i 的最小质因子。
  • i % primes[j] != 0，则说明 primes[j] 一定小于 i 的所有质因子，primes[j] 一定是 primes[j] * i 的最小质因子。

模板题AcWing868.筛质数

题目描述

给定一个正整数 n，请你求出 1∼n 中质数的个数。

输入格式

共一行，包含整数 n。

输出格式

共一行，包含一个整数，表示 1∼n 中质数的个数。

数据范围

1≤n≤10⁶。

输入样例

8

输出样例

4

C++代码

#include <iostream>
using namespace std;
const int N = 1000010;

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

/*朴素筛
void get_primes(int n)
{
    for(int i = 2; i <= n; i ++)
    {
        if(st[i]) continue;
        primes[cnt ++] = i;
        for(int j = i + i; j <= n; j += i)
            st[j] = true;
    }
}
*/

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

//线性筛
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 ++)
        {
            st[primes[j] * i] = true;
            if(i % primes[j] == 0) break;
        }
    }
}

int main()
{
    scanf("%d", &n);
    get_primes(n);
    printf("%d", cnt);
    return 0;
}

标签：1.1,int,质数,枚举,ai,因子,数学知识,primes
来源： https://www.cnblogs.com/Cocoicobird/p/16683316.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。