整除理论、约数、质数

这里只讲简单且必须会的东西。深奥的东西不谈。

和除法乘法有关系的题，大部分都和约数和倍数有关系，一开始就往这个方向想！！！

整除的基本知识（其实没啥用，太抽象）

注：a|b里面的a是小于等于b的，也就是说b是a的倍数
1.整除具有传递性
a|b, b|c -> a|c
2.

若a|b且a|c，那么对于任意的整数x，y，有a|（bx+cy）

根号n求约数

这也是一个板子，由于约数是成对出现的，因此我们可以枚举到根号n即可。

```cpp
#include <iostream>

using namespace std;

void divisors(int n)
{
	for(int i = 2; i <= n / i; i++)
	{
		if(n % i == 0)
		{
			cout << i << endl;//保存
			//如果像4的约数都是2和2，那么就只取一个就行了
			//也就是说判断这个成对的数是否相等，相等就保存一个即可。
			if(i != n / i) cout << n / i << endl;//保存
		}
	}
}

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

找最短的循环节

给一个长度为n的字符串，找它的最小循环节长度。比如"ababababab"，最短长度是2.

思路：循环字串的长度一定是总长的约数，因此先求出约数，然后去验证这些字串是否正确即可。

代码：

#include <iostream>
#include <string>

using namespace std;

const int N = 10010;
string s;
int divi[N];
int sz;
int ans = 0x7f7f7f7f;

void divisors(int n)
{
	for(int i = 1; i <=  n / i; i++)
	{
		if(n % i == 0)
		{
			divi[sz++] = i;
			if(i != n / i) divi[sz++] = n / i;
		}
	}
}

int minlength()
{
	//for(int i = 0; i < sz; i++) cout << divi[i] << endl;
	for(int i = 0; i < sz; i++)
	{
		string t = s.substr(0, divi[i]);
		//cout << t << endl;
		string tt;
		for(int j = 1; j <= s.size() / divi[i]; j++) tt += t;
		if(tt == s) ans = min(ans, divi[i]);
		//cout << tt << endl;
	}	
	return ans;
}

int main()
{
	cin >> s;
	divisors(s.size());
	int ans = minlength();
	cout << ans;
}

注：substr的第二个参数是字串的长度，不是第二个下标

拍头（*）

给定n和m个正整数，求每个数是另外的多少个数的倍数。n小于1e5,ai小于1e6.

这道题思路很值得学习。

首先暴力枚举每一个数，去找另外的能整除自己的数，找到之后++。
伪代码：

时间复杂度n²。明显过不了。

---

思路2：倍数就想到约数。可以先处理每一个数的约数，然后把对应约数在数组中出现的次数加上。如果和为s，那么这个数是另外s个数的倍数

有一个问题就是，我怎么知道对应约数出现了多少次？
直接遍历一遍数组的复杂度是n。那么整个算法的复杂度就变成了
根号n×n²(找约数是根号n，找约数次数是n，这个过程要循环n次）

这种优化还更烂了…

因此我们要预处理一下（这种预处理很常用，必须会）叫计数处理。
开一个数组，在读入数据的同时记录这个数据出现的次数。

模板

for(int i = 0; i < n; i++)
	cin >> a[i], cnt[a[i]]++;

cnt是存放数据出现次数的，这样预处理一下就可以让找约数次数变成O（1）的了。整体复杂度就是根号n×n。

注意：这个cnt数组的大小取决于ai最大的值，而不是题目给的n，因为它是以ai作为key值的哈希。

这个思路可以过。

ac代码：

#include <iostream>

using namespace std;

const int N = 1e6 + 10;

int a[N], cnt[N];

int n;

int main()
{
	cin >> n;
	for(int i = 0; i < n; i++) cin >> a[i], cnt[a[i]]++;
	for(int i = 0; i < n; i++)
	{
		int res = 0;
		//求约数
		for(int j = 1; j <= a[i] / j; j++)
		{
			if(a[i] % j == 0)
			{
				res += cnt[j];
				if(j != a[i] / j) res += cnt[a[i] / j];
			}
		}
		//最后记得减去自己，为什么自己想一想就知道了
		cout << res - 1 << endl;
	}
}

---

思路三
约数和倍数可以捆绑着去想。既然约数可以做，倍数是否也可以。
枚举每一个数，每次加上自己，找到自己的倍数。如果找到了，证明这个倍数是我的倍数，我出现的次数就是它答案的一部分。（其实就是约数的逆过程）

注：找倍数的过程其实是相当于制表。最后是相当于查表输出。
因为找倍数必须要是顺序的且没有重复数字出现的。

为什么要没有重复数字出现？举个例子：
2 4 8 10 2 8
第一次找2的倍数，4，8， 2， 8四个数字都被加了2出现的次数（两次），第5次又找2的倍数，4， 8， 2， 8四个数字都又被加了2出现的次数（两次），这就造成了重复计算了。

1. 其实枚举倍数相当于把一个数的因子都求出来了，然后把这个因子出现的次数加一起就是答案。
2. 而通过枚举倍数得到因子的前提就是没有重复元素（因子是不会相同的，有重复元素的时候枚举倍数相当于有重复因子）
3. 枚举因子的时候要从小到大枚举，可以通过j += i来枚举
4.

（看这个，例子看了没啥用）

因此要制表

伪代码：

for(int i = 1; i <= n; i++)
	for(int j = i; j <= n; j += i)//找i的倍数
		w[j] += cnt[a[i]];
		//j这个数是i的倍数，i出现的
		//次数就是j的答案的一部分.

ac代码：

#include <iostream>

using namespace std;

const int N = 1e6 + 10;

int a[N], cnt[N], w[N];

int n;

int main()
{
	cin >> n;
	for(int i = 0; i < n; i++) cin >> a[i], cnt[a[i]]++;
	for(int i = 1; i <= 1000000; i++)
		for(int j = i; j <= 1000000; j += i)
			w[j] += cnt[i];
	//查表
	for(int i = 0; i < n; i++) cout << w[a[i]] - 1 << endl;
}

时间复杂度是nlogn，因为第二个循环是j += i,是指数级别的。

质数与合数

合数是质数的对立面

线性筛

不需要特判2，2直接不会进循环，返回true

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

埃式筛

有一个推论：一个合数n可以被表示成两个质数相乘，且这两个质数一定有一个小于等于根号n。

埃式筛不是判定是否是质数的，而是筛选一定范围内的质数。
比如1-100内的质数，普通遍历加线性筛时间复杂度是根号n×n。
埃式筛的时间复杂度是nlnlnn，足以做简单数论题。

它的原理就是用到了上面的推论。根号n内的所有质数的倍数全部删去，剩下的就是质数。比如100以内的质数就是把2，3，5，7的倍数全部删掉剩下来的数。

模板：

bool a[N];

void E_sieve(int n)
{
	a[0] = a[1] = 1;//这一步可要可不要
	for(int i = 2; i <= n / i; i++)
	//小于等于根号n的质数可以组成所有合数
	{
		if(a[i] == 0)//如果这个数没有被筛掉，也就是质数
			for(int j = i * 2; j <= n; j += i)//把a[i]的倍数都筛掉
				a[j] = 1;
	}
}

说一下几个问题：

1. 为什么0表示质数1表示合数？其实都可以，只是0表示质数就不用初始化数组a了
   2.为什么第二个循环一开始就是i * 2?首先不能是i，因为i已经确定时质数了，其次2是最小的质数，乘以2可以找到离这个数最近的合数。

gcd和lcm

gcd

gcd就是辗转相除法

辗转相除法一句话解释就是较大数模较小数直到其中一个数为0.

观察下列过程

(16,10) -> (16 % 10, 10) -> (6, 10) -> (6, 10 % 6)
->(6, 4) -> (6 % 4, 4) -> (2, 4) -> (2, 4 % 2) -> (2, 0)
答案：2

因此用递归很好写

模板

int gcd(int x, int y)//默认x是较大数，y是较小数
{
	if(y == 0) return x;
	return gcd(y, x % y);//x%y之后变成较小数了，放在第二个参数
}

注：就算输入的时候让x较小了也无所谓，会自动换成x较大y较小的顺序。

时间复杂度最坏是log(max(x, y))，除了那么多次嘛。但一般时间都忽略不计，因为x和y的值太小了。

lcm

最小公倍数 = a * b / gcd(a, b)
模板

int lcm(int x, int y)
{
	return a / gcd(a, b) * b;//先除可以防止溢出
}

求多个数的最大gcd

一个一个求即可

(12, 18, 21) -> (6, 21) -> (3)

模板

int t = a[0];
for(int i = 1; i < n; i++)
	t = gcd(t, a[i])

最大公约数和最小公倍数问题

给定P,Q的最大公因数y和最小公倍数x。问有多少种P,Q的组合方式？

性质：PQ = XY

因此可以通过枚举P来得到Q，然后再验证P,Q的最大公因数是否为X即可。

又因为P是Y的约数，因此枚举Y的约数即可。

ac代码：

#include <iostream>

using namespace std;

int x, y, ans;

int gcd(int x, int y)
{
	if(y == 0) return x;
	return gcd(y, x % y);
}

int main()
{
	cin >> x >> y;
	for(int i = 1; i <= y / i; i++)
	{
		if(y % i == 0)
		{
			if(gcd(i, y / i * x) == x) ans++;
			if(i != y / i) 
				if(gcd(y / i, x * i) == x)
				 	ans++;
		}
	}
	cout << ans;
}

注：y / i * x不能写成其他形式，如果先乘的话就会爆int，因此1e11了，longlong倒是不会爆，所以多用long long吧。
也不能写成x / i * y,x有可能会小于i导致错误。

Hankson的趣味题

Hankson的趣味题

思路：枚举约数，验证这个约数的合法性。

ac代码：

#include <iostream>

using namespace std;

int n;
int a0, a1, b0, b1;

int gcd(int x, int y)
{
	if(y == 0) return x;
	return gcd(y, x % y);	
}

int lcm(int x, int y)
{
	return x / gcd(x, y) * y;
}

int main()
{
	cin >> n;
	for(int i = 0; i < n; i++)
	{
		int ans = 0;
		cin >> a0 >> a1 >> b0 >> b1;
		for(int j = 1; j <= b1 / j; j++)
		{
			if(b1 % j == 0)
			{
				if(gcd(a0, j) == a1)
					if(lcm(b0, j) == b1)
						ans++;
				
				if(j != b1 / j)
				{
					if(gcd(a0, b1 / j) == a1)
						if(lcm(b0, b1 / j) == b1)
							ans++;
				}
			}
		}
		cout << ans << endl;
	}
}

分析草稿