素数性测试（Robin-Miller算法）

算法分类：

随机算法

算法原理：

输入：一个大于3的奇整数n和一个大于等于1的安全参数t（用于确定测试轮数）。

输出：返回n是否是素数（概率意义上的，一般误判概率小于((1/2))⁸⁰)即可)。

1. 将n-1表示成2^sr

2. 对i从1到t做循环做以下操作：

   1. 选择一个随机整数a（2 ≤ a ≤ n−2）

   2. 计算y ← a^r bmod n

   3. 如果y≠1并且y≠ n−1循环做下面的操作，否则转3：

      1. j ← 1

      2. 当j ≤ s−1并且y ≠ n−1循环做下面操作，否则跳到（iv.）

      3. 计算y ← y² bmod n，如果y = 1返回“合数”，否则j ← j + 1

      4. 如果y ≠ n−1则返回“合数”

3. 返回“素数”

#include <iostream>  
using namespace std;  
  
/*===================================================== 
 * Fermat定理： 
 * 如果n是素数，那么对于所有的a<>0(mod n)有 
 * a^(n-1) mod n = 1 
 *===================================================== 
 */  
  
// 输出a^m(mod n)  
int expmod(int a, int m, int n) {  
    int c = 1;  
    while (m > 0) {  
        c = (c*c)%n;  
        if (m%2 == 1)  
            c = (c*a)%n;  
        m /= 2;  
    }  
  
    return c;  
};  
  
/*===================================================== 
 * 输入：正奇数>=5 
 * 输出：如果n是素数，则返回prime；否则返回composite 
 * 出错概率： 
 * 对于4~2000的所有合数，仅对341,561,645,1105,1387,1729 
 * 返回素数，此外，小于100,000的数中，仅有78个测试错误 
 * 最大的是93961 = 7*31*433 
 *===================================================== 
 */  
bool primeTest1(int n) {  
    if (expmod(2, n-1, n) == 1)   
        return true;  
    else  
        return false;  
};  
  
/*===================================================== 
 * Carmicheal数：  
 * 它对于相对于n互素的正整数a，满足Fermat定理 
 * Carmicheal数相当少，对于10^8内仅有255个。 
 * 当一个合数n对于底a满足Fermat定理时 
 * n被称为底a的伪素数，于是primeTest1在n是素数或者 
 * 是底2的伪素数时返回素数 
 *===================================================== 
 */  
  
/*===================================================== 
 * 改进方法： 
 * 在2~n-2之间随机地选择底，这产生了算法primeTest2 
 *===================================================== 
 */  
bool primeTest2(int n) {  
    // a是2~n-2之间的随机数  
    int a = rand()%(n-3) + 2;     
    if (expmod(a, n-1, n) == 1)  
        return true;  
    else  
        return false;  
};  
  
/*===================================================== 
 * 如果n不是Carmicheal数，则算法PTEST2将测出n是合数 
 * 的概率至少是1/2，换句话说primeTest2出错的概率最多 
 * 是1/2。于是，通过反复测试k次，出错的概率最多是2^(-k)  
 *===================================================== 
 */  
  
/*===================================================== 
 * 设n为大于5的奇数，写为n-1=(2^q)*m，则由费马定理， 
 * 序列a^m(mod n), a^(2m)(mod n), a^(4m)(mod n) 
 * ... a^((2^q)*m)(mod n) 必定以1结束，而且在1出现之前 
 * 的值必定是n-1，这是因为当n是素数时，x^2=1(mod n) 
 * 的唯一解是x=1或x=-1 
 *===================================================== 
 */  
  
// t为循环检测次数  
bool primalityTest(int n, int t) {  
    if (n == 2 || n == 3)   
        return true;  
      
    if (n%2 == 0)  
        return false;  
  
    int q = 0, m = n - 1;  
    while (m%2 == 0) {  
        ++ q;  
        m /= 2;  
    }  
  
    for (int i = 0; i < t; ++ i) {  
        int a = rand()%(n-2) + 2;  
        int x = expmod(a, m, n);  
        int j;  
  
        if (x == 1)  
            continue;  
  
        for (j = 0; j < q && x != n-1; ++ j) {  
            x = (x*x)%n;  
        }  
  
        if (j >= q)  
            return false;  
    }  
      
    return true;  
};  
  
int main()  
{  
    while(1) {  
          
        int n;  
      
        scanf("%d",&n);  
      
        if(primalityTest(n,10))  
            printf("n is a prime\n");  
        else   
            printf("n is not a prime\n");  
    }         
}  

#include <cstdio>
#include <cstdlib>
const int MAX = 4, N = 1000000;

long long PowerMod(long long a, long long b, long long k) {
    long long ret = 1, f = a;

    while (b) {
        if (b & 1)
            ret = ret * f % k;
        f = f * f % k;
        b >>= 1;
    }
    return ret;
}
bool MillerRabin(long long n) {
    int i;
    long long tmp;

    srand(100);
    for (i = 0; i < MAX; i++) {
        tmp = rand() % (n - 1) + 1;
        if (PowerMod(tmp, n - 1, n) != 1)
            break;
    }
    return (i == MAX);
}

int main() {
    long long n, i, j;
    bool tag[N] = {1, 1, 0};

    for (i = 2; i * i < N; i++) {
        if (tag[i]) continue;
        for (j = i; j * i < N; j++)
            tag[j*i] = 1;
    }
    while (scanf("%lld", &n) == 1) {
        if (n < N)
            printf("%s\n", tag[n] ? "NO" : "YES");
        else
            printf("%s\n", ((n & 1) == 0) || !MillerRabin(n) ? "NO" : "YES");
    }

    return 0;
}