文章目录
找最大公约数、找最小公倍数（分数的通分、约分）
C++如何找最大公约数（约分）（最大公因数）
【定义】两个数的最大公约数是能够被两个数整除的最大正整数。
常采用辗转相除法（欧几里得算法），公式为：gcd(a,b)=gcd(b,a mod b)
其实现代码如下：
int gcd(int a, int b)
{
if(b==0) return a;
return gcd(b, a%b);
}
但，其实C++11的标准库numeric含有现成的gcd函数，可以直接用它来找gcd(a,b)
C++如何找最小公倍数（通分）
最小公倍数 = 两数之积除以最大公约数，而最大公约数由上面的方法可得。而找一堆数的最小公倍数，递进下去即可：
//假设求nums数组内所有数的最小公倍数
int ans = 1;//毕竟分数，要从1开始
for(int i=0; i<nums.size(); i++)
{
ans = ans*nums[i] / (gcd(ans, nums[i]));
}
return ans;
应用-找连续区间内的最大公因数
其实只需要记住：
g
c
d
(
n
u
m
s
[
l
:
r
+
1
]
)
=
g
c
d
(
n
u
m
s
[
l
:
r
]
,
n
u
m
s
[
r
+
1
]
)
gcd(nums[l:r+1])=gcd(nums[l:r],nums[r+1])
gcd(nums[l:r+1])=gcd(nums[l:r],nums[r+1]),也就是说不断对新的增加的数求公因数即可。例如：当数组中只有9和27时，最大公因数为9，但是此时再加入个6，那么最大公因数就恢复成3了。因此需要一直求下去。但有一种情况除外，就是新加入的数连公因数k都没有，那么后面也一定不会再有k了
class Solution {
public:
int subarrayGCD(vector<int>& nums, int k) {
int n = nums.size(),ans = 0;
for(auto &num: nums) if(num == k) ++ans;
for(int i = 0; i < n; ++i) {
if(nums[i] % k == 0) {
int x = nums[i];
for(int j = i + 1; j < n; ++j) {
x = gcd(x, nums[j]);
if(x == k) ++ans;
//但是如果新的数连公因数k都没有，那么一定不可能再有k了
else if(x % k) break;
}
}
}
return ans;
}
};
应用-分数加减算法
这个题其实就是直接的分数操作，其思路也很明确：先把分子和分母提出来，分母通分的同时改好分母的值，随后分子相加完，再将分子分母约分即可，下面可见代码详解：
class Solution {
public:
string fractionAddition(string expression) {
vector<int>son,mom;
int sign = 1;//记录符号
int start = 0, n = expression.size();
//分子分母都抽出来
for(int i=0; i<n; ++i)
{
if(expression[i]=='-'||expression[i]=='+')
{
if(expression[i]=='-') sign = -1;
else sign = 1;
start = i+1;
}
//读分子
while(expression[i] != '/') i++;
int tem = sign * stoi(expression.substr(start,i-start));
son.push_back(tem);
start = i+1;
//读分母
while(i+1<n && isdigit(expression[i+1])) i++;
tem = stoi(expression.substr(start,i+1-start));
mom.push_back(tem);
}
//通分
int mom_v=1;
for(int i=0;i<mom.size();i++)
{
mom_v = (mom_v * mom[i]) / (gcd(mom_v,mom[i]));
}
for(int i=0;i<son.size();i++)
{
int tem = mom_v/mom[i];
son[i] *= tem;
}
//分子之间作加法
int son_v = 0;
for(auto &num:son)
{
son_v += num;
}
//约分
int yufen = gcd(son_v,mom_v);
string son_s = to_string(son_v /= yufen);
string mom_s = to_string(mom_v /= yufen);
return {son_s+'/'+mom_s};
}
};
素数、合数、公因数
素数和合数的定义
特别地，0，1既不是质数也不是合数。
【定义1】素数又称质数。所谓素数是指除了 1 和它本身以外，不能被任何整数整除的数，例如17就是素数，因为它不能被 2~16 的任一整数整除。
【定义2】除了0和1，不是素数的就是合数。一个合数一定由质数构成。
因此，单个判断是否是素数可以用试探法：
i从2枚举到n-1，如果n能被i整除，则为合数；如果都不能被i整除，则为质数；
如果n为合数，因子会成对出现，记为(x1, x2)，则必有
x
1
<
=
n
x1<=\sqrt{n}
x1<=n且
x
2
>
=
n
x2>=\sqrt{n}
x2>=n，因此我们再枚举i的时候，只需要枚举到
n
\sqrt{n}
n即可。
bool is_prime(int n)
{
if(n<2) return false;
else
{
//注意这里判断条件的巧妙之处
//原式需要i<sqrt(n)但是每次开方的计算量大
//而通过两面同时平方--i*i<=n 有爆int风险
//因此这里直接采用i<=n/i
for(int i=2;i<=n/i;i++)
if(n%i==0) return false;
}
return true;
}
//时间复杂度sqrt(n)
1、寻找范围内的区间素数之埃氏筛
因为一个合数一定由质数构成，因此我们通过把区间内所有合数删掉来到达快速找到素数的目的。例如：
假定我们要求100以内的质数，我们从2开始遍历。
遍历到2，2是质数，于是我们把2的所有倍数全部删除，比如4、6、8、10…
遍历到3，3是质数，于是我们把3的所有倍数全都删除，比如6、9、12、15…
遍历到4，4是合数已经删除，继续遍历，以此类推即可找到范围内所有的素数
代码如下所示：
void erichsen() {
int n = 100;
//是否是质数，1-质数 0-合数
vector<bool> isPrime;
isPrime.resize(n,true);
//因为对待质数主要是删除质数基础上的合数，因此后面的不必再去删除
//采用i < n / i 防止i*i超范围
for (int i = 2; i < n / i; i++) {
if (isPrime[i]) {
//删除i的倍数
for (int j = i * i; j < n; j += i) {
isPrime[j] = false;
}
}
}
int count = 0;
for (int i = 2; i < n; i++) {
if (isPrime[i]) {
count++;
}
}
cout << count << endl;
}
时间复杂度：O(nloglogn)
2、寻找范围内的区间素数之欧氏筛
欧拉筛是埃氏筛的改进版本，由于某些合数会有很多质因数，因此在删除的过程中会重复的删除，比如30，遍历到2时会进行删除，遍历到3时也会进行删除，所以为了避免这样的开销，欧拉筛将筛选出来的质数进行记录，在删除的过程中，只通过数的最小质因数筛数。
void euler() {
int n = 1e5;
//判断是否是质数
vector<bool> isPrime(n,true);
//存放质数
vector<int> primes;
int count = 0;
for (int i = 2; i < n; i++)
{
//1、先记录下来有哪些质数
if (isPrime[i])
{
primes.push_back(i);
count++;
}
//2、对每个数，都找其最小质数，去掉最近的数
//primes[j] * i就是找到的合数，其大小应该小于范围n
for (int j = 0; primes[j] * i < n; j++)
{
//每个质数都和i相乘 得到合数，删掉他们
isPrime[primes[j] * i] = false;
//primes[j]是i的一个质因数，保证是最小质因数
if (i % primes[j] == 0) break;
}
}
cout<< count <<endl;
}
9592
将其内部作为表打出来：
当i = 2 时
#j = 0 primes[j] = 2 primes[j] * i = 4
当i = 3 时
#j = 0 primes[j] = 2 primes[j] * i = 6
#j = 1 primes[j] = 3 primes[j] * i = 9
当i = 4 时
#j = 0 primes[j] = 2 primes[j] * i = 8
当i = 5 时
#j = 0 primes[j] = 2 primes[j] * i = 10
#j = 1 primes[j] = 3 primes[j] * i = 15
#j = 2 primes[j] = 5 primes[j] * i = 25
当i = 6 时
#j = 0 primes[j] = 2 primes[j] * i = 12
当i = 7 时
#j = 0 primes[j] = 2 primes[j] * i = 14
#j = 1 primes[j] = 3 primes[j] * i = 21
#j = 2 primes[j] = 5 primes[j] * i = 35
#j = 3 primes[j] = 7 primes[j] * i = 49
当i = 8 时
#j = 0 primes[j] = 2 primes[j] * i = 16
当i = 9 时
#j = 0 primes[j] = 2 primes[j] * i = 18
#j = 1 primes[j] = 3 primes[j] * i = 27
当i = 10 时
#j = 0 primes[j] = 2 primes[j] * i = 20
应用-按公因数计算最大组件大小
这个题很明显就是用查并集来做，关键是如何判断他们之间是存在有公因式的。我用最简单的gcd来找公因数，直接就TLE，因此需要另找个好方法来找公因式：
gcd是每两个数两两比较，因此是
n
2
n^2
n2的复杂度。而我们知道合数都是有质数构成的，我们可以通过直接让num与构成其的所有质数相连，从而达到一次遍历就完成的效果。随后可以通过清点每个数组的父节点来找到最多的那个父节点，输出有多少个指向它就行了。
class Solution {
public:
vector<int>parents;
vector<int>rank;
int max_rank = 0;
int largestComponentSize(vector<int>& nums) {
const int N = *max_element(nums.begin(),nums.end())+7;
parents.resize(N);
rank.resize(N);
//1、查并集初始化
for(int i=0; i<N; i++) parents[i] = i;
//2、完成素数筛选
vector<bool>is_prim(N,true);
vector<int>prim;
for(int i=2;i<N;i++)
{
if(is_prim[i]) prim.push_back(i);
for(int j=0;prim[j]*i<N;j++)
{
is_prim[prim[j]*i] = false;
if(i%prim[j]==0) break;
}
}
//3、遍历所有数，使其与自己的所有质因数连起来
for(auto &num:nums)
{
int tem = num;
int n = prim.size();
//这里的prim[j]*prim[j]<=tem原因是找构成的质数只需要找根号n范围的
//原因看上面的解释
for(int j=0;j<n && prim[j]*prim[j]<=tem;j++)
{
//这里找到构成他的质数就连接起来，随后继续找质因数
if(tem%prim[j]==0) link(num,prim[j]);
while(tem%prim[j]==0) tem /= prim[j];
}
//这个地方就是为了补偿上面sqrt(n)的，因为最后可能tem到了一个质数的情况
//而找质因数就肯定不会找自己嘛，因此这个判断最后一个数不是1就是另外的质数
//即是不是为大于1的数，是的话把他们一起连起来。
if(tem>1) link(num,tem);
}
//找到连接最多的点即可
int ans = 1;
vector<int>count(N);
//是否属于某个根，输出有多少个指向它
for(auto&num:nums)
{
ans = max(ans,++count[find(num)]);
}
return ans;
}
int find(int x)
{
if(x!=parents[x]) parents[x] = find(parents[x]);
return parents[x];
}
void link(int x, int y)
{
int p_x = find(x);
int p_y = find(y);
if(p_x == p_y) return;
parents[p_y] = p_x;
}
};
引用
此处的埃氏筛和欧拉筛都参考于京城大佬的题解
831
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
