素数筛法及习题

引入

素数是指只能被1和自身整除的数

• 初学编程的时候，只根据这个素数的这个定义，我们能够写出简单的判断素数或者素数打表的程序，大概如下

bool Is_prime(int n){
    if(n == 2) return true;
    if(n == 1||n % 2 == 0) return false; 
    for(int i = 3;i < n;i+=2) if(n % i == 0) return false;
    return true;
}
void Prime(int n){
    int tot = 0;
    for(int i=2;i<=n;i++){
        if(Is_prime(i)){
            p[tot++] = i;
        }
    }
}

• 后来又知道判断n的因子的时候不需要一直到n，只需要到根号n即可，所以可做优化如下

bool Is_prime(int n){
    if(n == 2) return true;
    if(n == 1||n % 2 == 0) return false; 
    for(int i = 3;i <= sqrt(n);i+=2) if(n % i == 0) return false;
    return true;
}
void Prime(int n){
    int tot = 0;
    for(int i=2;i<=n;i++){
        if(Is_prime(i)){
            p[tot++] = i;
        }
    }
}

• 这算不上筛法，只能算一种方法，它的时间复杂度大概是O（n√n），当n到达10⁶时，计算效率已经不可接受，需要寻求更好的方法

埃拉托色尼筛法

• 埃氏筛的核心思想在于用前面的质数去筛掉后面的数，根据算数基本定理，任何一个大于1的非质数都能分解成有限个质数乘积的形式
• 简单而言，就是用2筛掉它的所有倍数，用3筛它的所有倍数，用5筛它的所有倍数，一直往后
• 那么程序应该可以写出来

void Prime(int n){
    int tot = 0;
    for(int i=2;i<=n;i++){
        if(!vis[i]) p[tot++] = i;
        for(int j=2*i;j<=n;j+=i){
            vis[j] = 1;
        }
    }
}

• 可以做两个简单的优化，第一个，找因子的时候到√n就可以了；第二个，j从i*i开始，因为前面的已经算过了，比如i=4的时候，2*4，3*4在i=2和3的时候分别筛过，所以不需要再筛

void Prime(int n){
    int tot = 0;
    for(int i=2;i*i<=n;i++){
        for(int j=i*i;j<=n;j+=i){
            vis[j] = 1;
        }
    }
    for(int i=2;i<=n;i++){
        if(!vis[i]) p[tot++] = i;
    }
}

• 此筛法时间复杂度为O（nlog₂（log₂（n）））

欧拉筛法

• 埃氏筛存在一个问题，比如12这个数，它会被2和3分别筛掉一次，这样就造成了一种浪费，那么能不能把这个浪费去掉呢？
• 相对于12来说，2和3都是它的因子，那么如果想去掉一个，那么一定是3，因为我们是从小往大筛的，所以每次只用它的最小质因子筛，这样就可以做到只筛一次
• 这种筛法是线性的，所以也叫线性筛法

void Prime(int n){
    int tot = 0;
    for(int i = 2;i <= n;i++){
        if(!vis[i]) p[tot++] = i;
        for(int j = 0;j < tot&&i*p[j] <= n;j++){
            vis[i*p[j]] = 1;
            if(i % p[j] == 0) break;
        }
    }
}

• 如果找到最小质因子那么break

习题

首先先是模板题
n范围是10⁸，只能线性筛

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int MAXN = 1e8+100;
int Data[MAXN];
int p[MAXN];
int vis[MAXN];
void Prime(int n){
    int tot = 0;
    for(int i = 2;i <= n;i++){
        if(!vis[i]) p[tot++] = i;
        for(int j = 0;j < tot&&i*p[j] <= n;j++){
            vis[i*p[j]] = 1;
            if(i % p[j] == 0) break;
        }
    }
}
int main(){
    int n,q;
    scanf("%d%d",&n,&q);
    Prime(n);
    while(q--){
        scanf("%d",&n);
        printf("%d\n",p[n-1]);
    }
    return 0;
}

hdu1262

• 从偶数一半开始找，素数预先打表，查找的时候二分查找即可

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int MAXN = 2e5+100;
int Data[MAXN];
int p[MAXN];
int vis[MAXN];
void init(int n){
    int tot = 0;
    for(int i=2;i<=n;i++){
        if(!vis[i]) p[tot++] = i;
        for(int j=0;i*p[j]<=n&&j<tot;j++){
            vis[i*p[j]] = 1;
            if(i%p[j] == 0) break;
        }
    }
}
int main(){
    init(20000);
    int m;
    while(cin>>m){
        int t = m/2;
        int pos = lower_bound(p, p + 2000, t) - p;
        while(true){
            if(binary_search(p, p + 2000, m - p[pos])){
                cout<<m - p[pos]<<" "<<p[pos]<<endl;
                break;
            }
            pos++;
        }
    }
    return 0;
}

codeforces div2 B题
给定一个数d，现在要求一个可能的最小数a，使得a至少有4个除数，且除数之间距离最少是d

• 首先1和a一定是a的除数，那么至少还剩下两个除数，要想使除数之间距离最少是d，那么这两个除数必须是质数，假设它们是合数，那么根据算数基本定理，它们能分解成若干质数乘积，这些质数也是a的除数，这样除数之间距离又减小了；那么能不能有两个以上的除数呢？首先他们都是质数，如果是这样，那么a就是它们三个的乘积，这种情况求出的a不是最小值
• 所以首先要打素数表，找到第一个大于等于d+1的值，再找到第二个大于等于第一个值+d的值，乘积即为a

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <iomanip>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
const int MAXN = 1e5+100;
int p[MAXN];
int vis[MAXN];
void Prime(int n){
    int tot = 0;
    for(int i = 2;i <= n;i++){
        if(!vis[i]) p[tot++] = i;
        for(int j = 0;j < tot&&i*p[j] <= n;j++){
            vis[i*p[j]] = 1;
            if(i % p[j] == 0) break;
        }
    }
}
int main(){
    int t,d;
    Prime(50000);
    cin>>t;
    while(t--){
        cin>>d;
        int a = p[lower_bound(p, p + 10000, d + 1) - p];
        int b = p[lower_bound(p, p + 10000, a + d) - p];
        cout<<(1LL) * a * b<<endl;
    }
    return 0;
}

还有一道题未完待续

2021年9月11日更新

这道题给出了一个函数$f(i)$，意义是它能拆成几个非平方数（$1$不算）的乘积，举个例子$6=1\times 6=6\times 1=2\times 3=3\times 2$但是$4$只能拆成$2\times 2$

• 可以这样考虑，数据范围是$2e7$，可以将问题转化为求$ab\le n$的情况数，那么可先预处理出范围内所有的没有平方数因子的数，将其作为$a$，之后枚举每一个$b$求其方法数，再求和，这样时间复杂度可以降到很低
• 详细解释一下，比如说现在$a=1$，那么$\frac{n}{a}=n$，这里面有多少种情况呢？显然是有$1\times 2....n$这些情况，但是要去除掉平方数，而这些信息在预处理的时候已经完成了

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 0x3f3f3f3f;
const int MAXN = 2e7 + 100;
const double eps = 1e-6;
int p[MAXN];
int vis[MAXN];
int sum[MAXN];
ll MAX = 2e7;
int solve(){
    int tot = 0;
    for(ll i=2;i*i<=MAX;i++){
        for(int j=i*i;j<=MAX;j+=i*i){
            vis[j] = 1;
        }
    }
    for(int i=1;i<=MAX;i++){
        if(!vis[i]){
            sum[i] = sum[i - 1] + 1;
            p[tot++] = i;
        }else{
            sum[i] = sum[i - 1];
        }
    }
    return tot;
}
int main(){
    #ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
    #endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t, n;
    int len = solve();
    cin >> t;
    while(t--){
        cin >> n;
        ll ans = 0;
        for(int i=0;i<len && p[i] <= n;i++){
            ans += sum[n / p[i]];
        }
        cout << ans << '\n';
    }
    return 0;
}