数学知识1.1

2022-09-11 01:00:49 作者：互联网

一、简述

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

二、质数

质数和合数是针对所有大于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

输出样例

解题思路

试除法。

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⁶。

输入样例

输出样例

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