常见数论问题集合

1. 求最大公约数

• 欧几里得算法（辗转相除法）

int gcd(int a,int b){
    return b?gcd(b,a%b):a;
}

• 扩展欧几里得算法

int extgcd(int a,int b,int &x,int &y){
  int d=a;
  if(b){
    d=extgcd(b,a%b,y,x);
    y-=(a/b)*x;
    }
  else{
  x=1;y=0;
  }
  return d;
}

注：返回值d=gcd(a,b)，且ax+by=d。

2.素数

• 素性测试

bool is_prime(int n){
 for(int i=2;i*i<=n;i++){
   if(n%i==0) return false;
 }
 return n!=1;
}

• 埃氏筛法（时间复杂度为O(n loglog n)）
  思路：找到一个素数m时，就将n以内所有m的倍数都划去，像这样反复操作，就能依次枚举n以内的素数。
  例题：洛谷P3383线性筛素数
  c++代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=1e7+7;
bool is_prime[maxn];
int n,m;

int main(){
	cin>>n>>m;
	is_prime[0]=is_prime[1]=false;
	for(int i=2;i<=n;i++)
	is_prime[i]=true;
	for(int i=2;i<=n;i++){
		if(is_prime[i]){
			is_prime[i]=true;
			for(int j=2*i;j<=n;j+=i) 
			is_prime[j]=false;
		}
	}
	for(int i=0;i<m;i++){
		int a;
		cin>>a;
		if(is_prime[a]) cout<<"Yes"<<endl;
		else cout<<"No"<<endl;
	}
	return 0;
}

• 欧拉筛法（线性筛，时间复杂度为O(n) ）
  思路：利用每个合数必有一个最小素因子，保证每个合数仅被它的最小素因子筛去正好一次而不被重复筛。

const int maxn=100000001;
int prime[maxn];      //就是个素数表
bool sf[maxn];        //判断这个数是不是素数，sf[i]中的i是从1到maxn的数
void sushu(){         //核心 欧拉筛代码
    int num=0;        //num 用来记筛到第几个质数
    memset(sf,true,sizeof(sf));
    for(int i=2;i<=maxn;i++){          //外层枚举1~maxn
        if(sf[i]) prime[++num]=i;      //如果是质数就加入素数表
        for(int j=1;j<=num;j++){       //内层枚举num以内的质数
            if(i*prime[j]>maxn) break; //筛完结束
            sf[i*prime[j]]=false;      //筛掉...
            if(i%prime[j]==0) break;   //避免重复筛
        }
    }
    sf[1]=false;
    sf[0]=false;  //1 0 特判 
}

3.模运算

• 基本模运算
  若a≡b (% p)，则对于任意的c，都有(a + c) ≡ (b + c) (%p)；
  若a≡b (% p)，则对于任意的c，都有(a * c) ≡ (b * c) (%p)；
  若a≡b (% p)，c≡d (% p)，则 (a + c) ≡ (b + d) (%p)，(a - c) ≡ (b - d) (%p)，
  (a * c) ≡ (b * d) (%p)，(a / c) ≡ (b / d) (%p)；
• 分数取模
  小费马定理：a^p-1 mod p = 1 mod p
  对这个定理稍稍改动一下：a^p-2 mod p = a^-1 mod p，所以(b/a)%p=b*a^-1%p=b *a ^p-2%p。
• 快速幂运算（时间复杂度为O(logn）)

int ksm(int a ,int k) //a代表底数，k代表大指数
{
    int rec = 1;
    while( k )
    {
        if (k & 1)
            rec *= a;
        a *= a;
        k >>= 1;
    }
    return rec;
}

4.欧拉函数

• 定义：对正整数n，欧拉函数是小于或等于n的数中与n互质的数的数目。

• 欧拉定理：对于正整数N，代表小于等于N的与N互质的数的个数，记作φ(N)
  ①：如果n为某一个素数p，则φ ( p ) =p-1
  ②：如果n为某一个素数p的幂次，那么φ(p^a) =(p-1)p^(a-1)；
  ③：如果n为任意两个数a和b的积，那么φ(ab)=φ(a)φ(b)
  ④：设n=(p1^a1)(p2^a2)……(pk^ak) (为N的分解式)
  那么φ(n)=n*(1-1/p1)(1-1/p2)……*(1-1/pk)
  ⑤：a^(φ(m)) ≡1(mod m) (a与m互质)

• 欧拉函数的通式
  φ(n)=n*(1-1/p1)(1-1/p2)(1-1/p3)*(1-1/p4)……(1-1/pn)（pn为N的质因数）

• 递推求欧拉函数（时间复杂度为O(nlogn)）

void euler(int n) 
{ 
    for(re int i=1;i<=n;++i) 
    {
        p[i]=i; 
    }
    for(re int i=2;i<=n;++i) 
    { 
        if(p[i]==i)//如果i是质数
        { 
            for(re int j=i;j<=n;j+=i) 
            { 
                p[j]=p[j]/i*(i-1);//那么就把i的所有倍数筛出来 
            } 
        } 
    }
}

• 线性筛求欧拉函数（时间复杂度为O(n)）

void euler(int n) 
{
    p[1]=1;//1要特判 
    for(re int i=2;i<=n;++i) 
    { 
        if(!b[i])//这代表i是质数 
        { 
            prime[++num]=i; 
            p[i]=i-1; 
        } 
        for(re int j=1;j<=num&&prime[j]*i<=n;++j)//经典的欧拉筛写法 
        { 
            b[i*prime[j]]=1;//先把这个合数标记掉 
            if (i%prime[j]==0) 
            { 
                p[i*prime[j]]=p[i]*prime[j];//若prime[j]是i的质因子，则根据计算公式，i已经包括i*prime[j]的所有质因子 
             break;//经典欧拉筛的核心语句，这样能保证每个数只会被自己最小的因子筛掉一次 
            } 
            else 
            {
                p[i*prime[j]]=p[i]*p[prime[j]];//利用了欧拉函数是个积性函数的性质 
            }
        } 
    } 
}

• 欧拉函数的应用
  洛谷P2158仪仗队
  c++代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=40000;
int n,ans,e[maxn];

int main(){
	cin>>n;
	for(int i=1;i<=n;i++) e[i]=i;
	for(int i=2;i<=n;i++){
		if(e[i]==i){
			for(int j=i;j<=n;j+=i)
			e[j]=e[j]/i*(i-1);
		}
	}
	for(int i=1;i<n;i++)
	ans+=e[i];
	cout<<(n==1?0:2*ans+1);
	return 0;
}

5.位运算

• 常见位运算符

• 位运算技巧

1 .判断int型变量a是奇数还是偶数
a&1 = 0 偶数
a&1 = 1 奇数

2 . 取int型变量a的第k位
(k=0,1,2……sizeof(int))，即a>>k&1

3 . 将int型变量a的第k位清0，即a=a&~(1<<k)

4 . 将int型变量a的第k位置1， 即a=a|(1<<k)

5 . int型变量循环左移k次，即a=a<<k|a>>16-k (设sizeof(int)=16)

6 . int型变量a循环右移k次，即a=a>>k|a<<16-k (设sizeof(int)=16)

7 .整数的平均值
对于两个整数x,y，如果用 (x+y)/2 求平均值，会产生溢出，因为 x+y 可能会大于INT_MAX，但是我们知道它们的平均值是肯定不会

int average(int x, int y) //返回X,Y 的平均值
{
return (x&y)+((x^y)>>1);
}

8 . 判断一个整数是不是2的幂,对于一个数 x >= 0，判断他 是不是2的幂

boolean power2(int x)
{
return ((x&(x-1))==0)&&(x!=0)；
}

9 .不用temp交换两个整数
void swap(int x , int y)
{
x ^= y;
y ^= x;
x ^= y;
}

10 . 计算绝对值
int abs( int x )
{
int y ;
y = x >> 31 ;
return (x^y)-y ; //or: (x+y)^y
}

11 . 取模运算转化成位运算 (在不产生溢出的情况下)
a % (2^n) 等价于 a & (2^n - 1)

12 .乘法运算转化成位运算 (在不产生溢出的情况下)
a * (2^n) 等价于 a<< n

13 . 除法运算转化成位运算 (在不产生溢出的情况下)
a / (2^n) 等价于 a>> n
例: 12/8 == 12>>3

14 . a % 2 等价于 a & 1 ( a & log2(2))
a % 4 等价于 a & 2 ( a & log2(4))
···
a % 32 等价于 a & 5

15 . if (x == a) x= b;
　　 else x= a;
等价于 x= a ^ b ^ x;

16 . x 的 相反数 表示为 (~x+1)

17 .x的二进制的最后一个1：x&-x

如果想要得到更多知识，请关注我博客：wlis.blog.csdn.net

此博客不定期更新内容！！！感谢大家！！！