数论基础入门

一、整除

1.整除的性质

1）自反性

n|n

2）传递性

若a|b，b|c，则a|c

3）反对称性

若a|b，b|a，则a=b

1.5. 特殊的整除

原理：随时取模性质

2.求[1,n]内约数个数

#include<iostream>
using namespace std;
int a[1000];
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n/i;j++)
		a[i*j]++;
	}
	for(int i=1;i<=n;i++) cout<<i<<" "<<a[i]<<endl;
	return 0;
}

时间复杂度：O ( n log n )
时间复杂度证明方式：调和级数

3.判断是不是质数

#include<iostream>
using namespace std;
bool is_prime(int x)
{
	if(x==1) return false;
	for(int i=2;i*i<=x;i++)//使用i*i算多次，但单次耗时少，用sqrt算一次，但是单次耗时多，所以两种写法均可
	{
		if(x%i==0) return false;
	}
	return true;
}
int main()
{
	//while(1)
	//{
		int n;
		cin>>n;
		if(is_prime(n)) cout<<"Yes";
		else cout<<"No";
	//}
	return 0;
}

时间复杂度O ( $\sqrt{n}$ )
由于因数成对出现，所以只需要先找到最对称的位置——根号n，然后任选一边进行枚举，通常选的是[ 1，$\sqrt{n}$ ]
规定1既不是质数也不是合数

4.求[1,n]内的质数个数

如果每个数都判断一遍是不是质数，那么时间复杂度是O( n$\sqrt{n}$ )
改用埃氏筛，时间复杂度可以降到近似 O ( n )

#include<iostream>
using namespace std;
int a[1000];
int main()
{
	int n;
	cin>>n;
	for(int i=2;i<=n;i++)
	{
		if(a[i]==1) continue;
		for(int j=2;i*j<=n;j++)
		a[i*j]=1;
	}
	for(int i=2;i<=n;i++)
	{
		if(a[i]) cout<<i<<" "<<"No"<<endl;
		else cout<<i<<" "<<"Yes"<<endl;
	}
	return 0;
}

小优化：

#include<iostream>
using namespace std;
int a[1000];
int main()
{
	int n;
	cin>>n;
	for(int i=2;i*i<=n;i++) //同样只遍历到根号n，因为i是筛的因数
	{
		if(a[i]==1) continue;
		for(int j=2;i*j<=n;j++)//j是另一个因数
		a[i*j]=1;
	}
	//对i限制，而j不限制，这样最能利用时间
	for(int i=2;i<=n;i++)
	{
		if(a[i]) cout<<i<<" "<<"No"<<endl;
		else cout<<i<<" "<<"Yes"<<endl;
	}
	return 0;
}

洛谷P3383题解：

#include<cstdio>
using namespace std;
int a[100000000],prime[100000000];
int main()
{
	//std::ios::sync_with_stdio(0);
	int n,q;
	scanf("%d%d",&n,&q);
	//cin>>n>>q;
	for(int i=2;i*i<=n;i++)
	{
		if(a[i]==1) continue;
		for(int j=2;i*j<=n;j++)
		a[i*j]=1;
	}
	int cnt=1;
	for(int i=2;i<=n;i++)
	{
		if(a[i]==0) 
		{
			prime[cnt]=i;
			cnt++;
		}
	}
	int c;
	for(int i=1;i<=q;i++)
	{
		scanf("%d",&c);
		//cin>>c;
		printf("%d \n",prime[c]);
		//cout<<prime[c]<<endl;
	}
	return 0;
}

这个题卡常数，只能用C语言的输出方式

5.分解质因数

#include<iostream>
using namespace std;
int a[1000];
int main()
{
	int n;
	cin>>n;
	int cnt=0;
	for(int i=2;i*i<=n;i++)
	{
		if(n==1) break;
		while(n%i==0) 
		{
			cnt++;
			a[cnt]=i;
			n/=i;
		}
	}
	if(n!=1) a[++cnt]=n;
	for(int i=1;i<=cnt;i++)
	cout<<a[i]<<" ";
	return 0;
}

一个数的因数都是成对出现的，所以一定有小于$\sqrt{n}$的，也一定有大于$\sqrt{n}$的，只需要枚举小于$\sqrt{n}$的部分
对于大于$\sqrt{n}$的部分，如果还是个合数，那么可能被分解的全部小于$\sqrt{n}$
如果本身是较大的质数，那么会留下来，没有除干净

二、取模

1.正、负数的取模

对于Python：-2对5取模是3
对于C++：-2对5取模是-2
那么未知正负下的取模方式：$ （ a % b + b ) % b $

2.随时取模性质

对于只含加法、减法、乘法的式子，中间过程随意取模+结果取模与结果取模等价，但要注意减法要避免最后模出来个负数

三、取整

取整的性质

或者更严谨一点，传送门：关于向下取整的性质

四、gcd和lcm

gcd 是最大公因数
lcm 是最大公倍数
如果 gcd ( a , b ) == 1 ，那么就说 a 和 b 互质
如果 lcm ( a , b ) == a * b , 那么就说 a 和 b 互质

1.求gcd和lcm

#include<iostream>
using namespace std;
int a,b,c;
int prime[1000],prime_num[1000],prime_sum[1000];
int main()
{
	cin>>a>>b;
	c=a>b? a:b;
//	for(int i=2;i*i<=c;i++)
//	{
//		if(prime[i]==1) continue;
//		for(int j=2;i*j<=c;j++)
//		prime[i*j]=1;
//	}
//	int cnt=0;
//	for(int i=2;i<=c;i++)
//	if(prime[i]==0) prime_num[++cnt]=i;
	int gcd=1;
	int a1=a,b1=b;
	for(int i=2;i*i<=c;i++)
	{
		while(a1%i==0&&b1%i==0)
		{
			gcd*=i;
			a1/=i;
			b1/=i;
		}
	}
	cout<<gcd<<endl;
	
	int lcm=1;
	a1=a;b1=b;
	for(int i=2;i*i<=c;i++)
	{
		while(a1%i==0&&b1%i==0)
		{
			lcm*=i;
			a1/=i;
			b1/=i;
		}
		while(a1%i==0)
		{
			lcm*=i;
			a1/=i;
		}
		while(b1%i==0)
		{
			lcm*=i;
			b1/=i;
		}
	}
	cout<<lcm;
	return 0;
}

直接分解质因数的做法不是最优解，gcd可以改用辗转相除法，然后lcm用gcd和lcm的性质算出来

2.gcd和lcm的性质

gcd * lcm = a * b
因为全部的质因数均会乘进去

3.辗转相除法

gcd递归定理:

gcd(a,b)=gcd(a,a%b)

本质：乘法分配律

#include<iostream>
using namespace std;
int gcd(int a,int b)
{
	if(b==0) return a;
	else return gcd(b,a%b);
}
int main()
{
	int x,y;
	cin>>x>>y;
	if(x<y) swap(x,y);
	cout<<gcd(x,y)<<endl;
	return 0;
}