素数

1. 普通筛........

2. 埃氏筛

　　算术基本定理(正整数唯一分解定理)应用

　　复杂度 听说是O(nloglogn) 听说证明挺鬼畜

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

const int MAXN = 11111111;
bool isPrime[MAXN];

int main(){
    //freopen("test.txt", "w", stdout);
    memset(isPrime, true, sizeof(isPrime));
    int x = 0, k = ceil(sqrt(MAXN));
    for(int i = 2; i < k; ++i){
        if(isPrime[i])
            for(int j = i; i * j < MAXN; ++j)
                isPrime[i*j] = false;
    }
    for(int i = 2; i < MAXN; ++i) 
        if(isPrime[i])
            printf("%d ", i);
    return 0;
}

3. 欧拉筛

　　还是跟埃氏筛一样用算术基本定理

　　但是埃氏筛对于某些数会多次筛除

　　欧拉筛使合数只被其最小质因数筛除  时间复杂度为 O(n)

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

const int MAXN = 11111111;
int prime[MAXN];
bool isPrime[MAXN];

int main(){
    //freopen("book.txt", "w", stdout);
    memset(isPrime, true, sizeof(isPrime));
    int x = 0;
    for(int i = 2; i < MAXN; ++i){
        if(isPrime[i]) prime[x++] = i;
        for(int j = 0; j < x; ++j){
            if(i * prime[j] >= MAXN) break;
            isPrime[i*prime[j]] = false;
            if(i % prime[j] == 0) break;
        }
    }
    for(int i = 0; i < x; ++i) printf("%d ", prime[i]);
    return 0;
}

精髓是 if(i % prime[j] == 0) break; 

当某个数能被某质数整除时，后面的这个数的倍数的最小质因子一定是当前的质数而不是其他的质数，所以退出循环

例如： 当 i == 6 时筛去(6 * 2 = )12后，6被2整除，说明6*3、6*5的最小质因数是2，而不是3和5

4.Miller_rabin强伪素数测试

Int64以内Rabin-Miller强伪素数测试 和Pollard 因数分解的算法实现

typedef long long ll;
ll mul_mod(ll a, ll b, ll m){
    ll ans = 0, exp = a;
    while(exp >= m) exp -= m;
    while(b){
        if(b & 1){
            ans += exp;
            while(ans >= m) ans -= m;
        }
        exp += exp;
        while(exp >= m) exp -= m;
        b >>= 1;
    }
    return ans;
}
ll pow_mod(ll x, ll n, ll m){
    ll ans = 1, exp = x;
    while(exp >= m) exp -= m;
    while(n){
        if(n & 1) ans = mul_mod(ans, exp, m);
        exp = mul_mod(exp, exp, m);
        n >>= 1;
    }
    return ans;
}
bool miller_rabin(ll n){
    if(n < 2) return false;
    if(n == 2) return true;
    if(!(n & 1)) return false;
    ll p = n - 1;
    int k = 0;
    while(!(p & 1)){
        ++k;
        p >>= 1;
    }
    for(int i = 0; i < 20; ++i){
        ll a = rand() % (n - 1) + 1;
        ll x = pow_mod(a, p, n);
        if(x == 1) continue;
        bool flag = false;
        for(int j = 0; j < k; ++j){
            if(x == n - 1){
                flag = true;
                break;
            }
            x = mul_mod(x, x, n);
        }
        if(flag) continue;
        return false;
    }
    return true;
}

附：POJ 2429 代码

#include <map>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long ll;

ll mul_mod(ll a, ll b, ll mod){
    ll ans = 0, exp = a;
    while(exp >= mod) exp -= mod;
    while(b){
        if(b & 1){
            ans += exp;
            if(ans >= mod) ans -= mod;
        }
        exp <<= 1;
        if(exp >= mod) exp -= mod;
        b >>= 1;
    }
    return ans;
}
ll pow_mod(ll x, ll n, ll mod){
    ll ans = 1, exp = x;
    while(exp >= mod) exp -= mod;
    while(n){
        if(n & 1) ans = mul_mod(ans, exp, mod);
        exp = mul_mod(exp, exp, mod);
        n >>= 1;
    }
    return ans;
}

const int MP = 233333;
vector<int> primes;
vector<bool> isprime;
void init_primes(){
    isprime = vector<bool>(MP, true);
    isprime[0] = isprime[1] = false;
    for(int i = 2; i < MP; ++i){
        if(isprime[i]) primes.push_back(i);
        for(int j = 0; j < primes.size() && i * primes[j] < MP; ++j){
            isprime[i * primes[j]] = false;
            if(i % primes[j] == 0) break;
        }
    }
}
bool miller_rabin(ll n){
    if(n < 2) return false;
    if(n == 2) return true;
    if(!(n & 1)) return false;
    ll p = n - 1;
    int k = 0;
    while(!(p & 1)){
        ++k;
        p >>= 1;
    }
    for(int i = 0; i < 20; ++i){
        ll a = rand() % (n - 1) + 1;
        ll x = pow_mod(a, p, n);
        if(x == 1) continue;
        bool flag = false;
        for(int j = 0; j < k; ++j){
            if(x == n - 1){
                flag = true;
                break;
            }
            x = mul_mod(x, x, n);
        }
        if(flag) continue;
        return false;
    }
    return true;
}
bool is_prime(ll n){
    if(n < MP) return isprime[n];
    else return miller_rabin(n);
}

ll pollard_rho(ll n, int a){
    ll x = 2, y = 2, d = 1;
    while(d == 1){
        x = mul_mod(x, x, n) + a;
        y = mul_mod(y, y, n) + a;
        y = mul_mod(y, y, n) + a;
        if(x == y) break;
        d = __gcd((x >= y ? x - y : y - x), n);
    }
    if(d == 1 || d == n) return pollard_rho(n, a + 1);
    return d;
}
void factorize(ll n, map<ll, int>& factors){
    if(is_prime(n)) ++factors[n];
    else{
        for(int i = 0; i < primes.size(); ++i)
            while(!(n % primes[i])){
                ++factors[primes[i]];
                n /= primes[i];
            }
        if(n != 1){
            if(is_prime(n)) ++factors[n];
            else{
                ll d = pollard_rho(n, 1);
                factorize(d, factors);
                factorize(n / d, factors);
            }
        }
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    ll a, b;
    init_primes();
    while(cin >> a >> b){
        ll c = b / a;
        map<ll, int> factors;
        factorize(c, factors);
        vector<ll> p_factors;
        for(map<ll, int>::iterator it = factors.begin(); it != factors.end(); ++it){
            ll tmp = 1;
            while(it->second--) tmp *= it->first;
            p_factors.push_back(tmp);
        }
        ll x = 1, y = c, sum = 1e18;
        for(int i = 0; i < (1 << p_factors.size()); ++i){
            ll tx = 1;
            for(int j = 0; j < p_factors.size(); ++j)
                if(i & (1 << j))
                    tx *= p_factors[j];
            ll ty = c / tx;
            if(tx < ty && tx + ty < sum){
                x = tx;
                y = ty;
                sum = x + y;
            }
        }
        cout << x * a << " " << y * a << endl;
    }
    return 0;
}