数论（质数检验、最大公约数、幂乘）

需具备知识：数组、循环、递归函数

一、质数检验

1.什么是质数？

质数别名素数，是指除了1和自身之外，再没有其他因数的数。

特别：1 不是质数，最小的质数是 2

检验质数的算法：

isPrime(int x){
	if(x <= 1){
		return 0;
	}
	for(int i=0; i<x-1; i++){  //检验 x 是否被 2 到 x-1 之间的整数整除
		if(x % i == 0){
			return 0;  // 能整除则不是质数，返回 0
		}
	}
	return 1;
}

从 2 到 x-1 逐个检验，复杂度为 O(X)，效率低

改进算法：

①除 2 以外，所有的偶数都不是质数，能减少一半复杂度；
②x 不能被大于 x/2 的数整除，又减少一半复杂度。

虽然以上能够有所改进，但是整个算法的复杂度还是 O(X)。

可以利用 “合数” 的性质（一个合数能被写为两个质数的积）
什么是合数？？

例：检验 31 是否是质数时，只需检验 31 能否被 2~6 之间的整数整除即可，
如果 7~30 之间存在能整除 31 的整数，那么 2 到 6 中必然也存在能整除 31 的整数，所以检查大于 6 的整数就是浪费资源。

利用这条性质，检验范围缩小为 x ~ sqrt(x)，复杂度为 O( sqrt(x) )

算法：

isPrime(int x){
	if( x < 2) return 0;
	if( x == 2 ) return 1;
	if( x % 2 == 0 ) return 0;  //x 是偶数，返回0
	for( int i=3; i*i <= x; i++ ){  //也可使用 math 函数库的 sqrt()
		if( x % i == 0 ) return 0;
	}
	return 1;
}

**

埃拉托色尼筛选法：

1.列举大于等于2的整数
2.留下最小的整数2，删除所有2的倍数
3.在留下的整数中留下最小的3，删除所有3的倍数
4.在留下的整数中留下最小的5，删除所有5的倍数
5.以此类推，留下仍未被删除的最小整数，删除该整数的倍数，直到循环结束

The Sieve of Eratosthenes：

void eratos(int n){
	int isprime[n];  //isprime[x] 为 1 ，表示 x 是质数，否则，x 为合数
	for( int i=0; i<=n ; i++){  //将 n 个数作为筛选对象
		isprime[i] = 1;
	}
	isprime[0] = isprime[1] = 0;  // 0 和 1 排除
	for( int i=2; i*i<=n; i++){
		if( isprime[i] == 1){
			int j = i + i;    // 留下 i ，删除 i 的倍数
			while( j <= n ){
				isprime[j] = 0;  // 令 i 的倍数置 0，不是质数
				j += i;  // 寻找 i 的倍数，通过不断加自身实现
			}
		}
	}
}

埃拉托色尼筛选法需占用一部分空间（与待检验整数的最大值N成正比），
但是复杂度仅为O（N㏒ ㏒N）

例题：

1. ADV-354 质数
2. ADV-355 质数2

二、最大公约数

求最大公约数的简单算法 ：

**

int gcd( int x,int y ){
	int n = x<y?x:y;  //三目运算，令 n 等于 x 和 y 之间最小的数
	for( int i=n; i>=1; i--){  // i 从大到小运算，找出的既是最大公约数
		if( x%i==0 && y%i==0 ){
			return i;
		}
	}
}

将 x 和 y 最小的作 n，从 n 到 1 依次检查，如果有最大公约数就返回当时的 i
但是复杂度大，不适合大数据的检验

欧几里得算法：

又称 “辗转相除法” ，

利用了 “ 当 x>=y 时 2，gcd(x，y ) 等于 gcd(y，x 除以 y 之后的余数)” 这一定理

例：
求 74 和 54 的最大公约数
gcd(74, 54)
=gcd(54, 74%54) = gcd(54, 20)
=gcd(20, 54%20) = gcd(20, 14)
=gcd(14, 20%14) = gcd(14, 6)
=gcd(6, 14%6) = gcd(6, 2)
=gcd(2, 6%2) = gcd(2, 0)
=2

对于gcd(a,b), 当 b = 0 时，a 就是给定的整数 x，y 的最大公约数

欧几里得算法：

int gcd(int x, int y){
	if( x < y ){           //确保 x 大于等于 y
		int temp = x;
		x = y;
		y = temp;
	}
	while( y > 0 ){
		int r = x % y;
		x = y;
		y = r;
	}
	return x;
}

递归求最大公约数——欧几里得算法：

#include<bits/stdc++.h>

using namespace std;

int gcd(int x,  int y){         //递归函数
	return y ? gcd(y, x%y) : x;
}

int main(){
	int a, b;
	cin >> a >> b;
	cout << gcd(a, b) << endl;
	return 0; 
}

循环求最大公约数——欧几里得算法：

#include<bits/stdc++.h>

using namespace std;

int gcd(int x,  int y){
	if(x < y){          //确保 x > y
		int temp = x;
		x = y;
		y = temp;
	}
	
	while(y > 0){       //利用循环
		int temp = x % y;
		x = y;
		y = temp; 
	}
	
	return x;	
}

int main(){
	int a, b;
	cin >> a >> b;
	cout << gcd(a, b) << endl;
	return 0; 
}

三、幂乘

例：现有两个整数 m、n，求 m 的 n 次方除以 1000000007 的余数。
1 <= m <= 100
1 <= n <= 10^9

如果用最直接的方法求，需要进行 n-1 次乘法运算，算法复杂度为 O( n ) .

可以采用 x^n = (x^2) ^ (n/2) 的性质。

举个例子：

求 3^21。
解：
3^21 = (3 x 3)^10 x 3
9^10 = (9 x 9)^5
81^5 = (81 x 81)^2 x 81
6521^2 = (6521 x 6521)
这样计算，可以把乘法运算由原来的20次减少到6次。

反复平方算法 ：

int pos(int x, int n){    //递归
	int res;
	if(n == 0){
		return 1;
	}
	res = pow(x*x, n/2);
	if(n % 2 == 1){
		res = res * x;
	}
	return res;
}

反复平方算法，递归函数的参数 n 逐次减半，
算法复杂度为 0(log n).

开头例题的解：

#include<bits/stdc++.h>  //万能头文件

using namespace std;

typedef long long llong;
typedef unsigned long long ullong;

llong mod_pow(ullong x, ullong n, ullong mod){  
	ullong res = 1;
	while( n > 0 ){
		if( n & 1 ) res = res * x % mod;
		x = x * x % mod;
		n >>= 1; 
	}
	return res;
}

int main(){
	ullong a, b;
	cin >> a >> b;
	cout << mod_pow(a, b, 1000000007);
	return 0;
}