质数 (数论)

试除法判定质数

小于2的数不是质数(1既不是质数也不是合数),之后的数从2开始依次判断能否被x整除,如果可以则不是质数,否则的话则除了1和本身没有其他因子所以是质数;

AC代码

#include <iostream>
#include <algorithm>

using namespace std;

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

int main()
{
    int n;
    cin >> n;

    while (n -- )
    {
        int x;
        cin >> x;
        if (is_prime(x)) puts("Yes");
        else puts("No");
    }

    return 0;
}

分解质因数

质因数概念

质因数（素因数或质因子）在数论里是指能整除给定正整数质数。除了1以外，两个没有其他共同质因子的正整数称为互质。因为1没有质因子，1与任何正整数（包括1本身）都是互质。正整数的因数分解可将正整数表示为一连串的质因子相乘，质因子如重复可以用指数表示。根据算术基本定理，任何正整数皆有独一无二的质因子分解式 [1] 。只有一个质因子的正整数为质数。

每个合数都可以写成几个质数（也可称为素数）相乘的形式 [2] ，这几个质数就都叫做这个合数的质因数。如果一个质数是某个数的因数，那么就说这个质数是这个数的质因数；而这个因数一定是一个质数。

一个大于1的自然数N,如果N不为质数,那么一定可以分解为N = p1^a1 * p2^a2 …*pn^an;(分解为质因子的次幂乘积)
证明一下循环里面的 i 一定是一个质数：假如 i 是一个合数，那么它一定可以分解成多个质因子相乘的形式，这多个质因子同时也是 a 的质因子且比 i 要小，而比 i 小的数在之前的循环过程中一定是被条件除完了的，所以 i 不可能是合数，只可能是质数

n中最多只含有一个大于sqrt(n)的因子。证明通过反证法：如果有两个大于sqrt(n)的因子，那么相乘会大于n，矛盾。

说得好 最后剩下的要么是1，要么是唯一的大于原数开方的质因子

AC思想

for循环中的i一定是质数,n/i保证了根号n的时间复杂度(n/i减少无用搜索,防止越界),最后剩下的要么是1,要么是唯一的大于原数开方的质因子

AC代码

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

void divide(int n){
    for(int i=2;i<=n/i;i++){
        if(n%i==0){       //n不包含任何从2到i-1之间的质因子（已经被除干净了）
                          //(n%i==0)所以i也不包含何从2到i-1之间的质因子，由质数的定义可知，保证了i是质数
            int s=0;
            while(n%i==0) n/=i,s++;  
            cout<<i<<' '<<s<<endl;
        }
    }  
    if(n>1) cout<<n<<' '<<1<<endl;    //最多只有一个大于根下n的质因子（两个相乘就大于n了）
    cout<<endl;
}

int main(){
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int a;
        cin>>a;
        divide(a);
    }
}

质数筛法

朴素筛法(nlogn)

用每一个质数排除掉它的所有倍数;

#include <iostream>
#include <algorithm>

using namespace std;

const int N= 1000010;

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;
    }
}

int main()
{
    int n;
    cin >> n;

    get_primes(n);

    cout << cnt << endl;

    return 0;
}

线性筛法(n)

在朴素筛法的情况下,我们发现有的数会被重复筛掉,所以我们进行改进,利用最小质因数进行筛取,保证它的倍数都是被它的最小质因子给筛掉的

prime[j] * i <= n 保证只筛取n大小的范围
(1)当i%primes[j]!=0时,说明此时遍历到的primes[j]不是i的质因子，那么只可能是此时的primes[j]是<i的
最小质因子,所以primes[j]*i的最小质因子就是primes[j],然后筛去;
(2)当有i%primes[j]==0时,说明i的最小质因子是primes[j],因此primes[j]*i的最小质因子也就应该是
prime[j]，之后接着用st[primes[j+1]*i]=true去筛合数时，就不是用最小质因子去更新了,因为i有最小
质因子primes[j]<primes[j+1],此时的primes[j+1]不是primes[j+1]*i的最小质因子，此时就应该
退出循环，避免之后重复进行筛选。

#include <iostream>
#include <algorithm>

using namespace std;

const int N= 1000010;

int primes[N], cnt;
bool st[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;
        }
    }
}

int main()
{
    int n;
    cin >> n;

    get_primes(n);

    cout << cnt << endl;

    return 0;
}

Rabin-Miller大素数判定

#include<iostream>
#include<stdlib.h>
using namespace std;
typedef long long ll;
ll mm(ll a,ll b,ll mod){//快速积取模 
	ll ans=0;
	while(b){
		if(b&1) ans=(ans+a)%mod;
		a=(a+a)%mod;
		b>>=1;
	}
	return ans;
}
 ll f(ll x,ll n,ll mod){//快速幂取模 
	ll ans=1;
	while(n){
		if(n&1) ans=mm(ans,x,mod);
		x=mm(x,x,mod);
		n>>=1;
	}
	return ans;
}
bool miller_rabin(ll n){//Miller-Rabin素数检测算法 
	if(n==2)
	  return true;
	else if(n==1||n%2==0)
	  return false;
	ll u=n-1,t=0;
	while(u%2==0) u/=2,t++;//n-1=u*2^t 
	for(int i=0;i<10;i++){
		//随机选取一个底数a 
		ll a=rand()%(n-1)+1;
		//计算(a^(n-1))%n=(a^(u*2^t))%n
		ll x=f(a,u,n);//先计算(a^u)%n
		for(int j=1;j<=t;j++){//再经过t次循环计算得到 ( (a^u)^(2^t) )%n
			ll y=mm(x,x,n);
			if(y==1&&x!=1&&x!=n-1)//如果不满足二次探测定理，则不是素数 
			  return false;
			x=y;
		}
		if(x!=1) return false;//如果不满足费马小定理，则不是素数 
	 } 
	 return true;//是素数 
}
int main(){
    int t;
    ll n;
    scanf("%d",&t); 
    while(t--){
        scanf("%lld",&n);
        printf("%s\n",miller_rabin(n)?"Yes":"No");
    }
    return 0;
}