算法竞赛进阶指南-第四章-约数

title: 算法竞赛进阶指南-第四章-约数
date: 2023-02-04 11:13:12
tags:

约数

定义

若整数n除以整数d的余数为0,即d能整除n,则称d是n的约数,n是d的倍数,记为d|n

算法基本定理的推论

求N的正约数集合—试除法

若d>=sqrt(N)是N的约数,则N/d<=sqrt(N)也是N的约数

因此,只需要扫描1~sqrt(N)

int factor[1600], m = 0;
for(int i = 1; i*i <= n; i++)
{
	if(n%i == 0)
    {
        factor[++m] = i;
        if(i != n/i) factor[++m] = n/i;
    }
}
for(int i = 1; i <= m; i++)
    cout << factor[i] << endl;

推论:一个整数N的约数个数上界为2*sqrt(N)

求1~N每个数的正约数集合—倍数法(O(NlogN))

1~N中以d为约数的数就是d的倍数

vector<int> factor[500010];
for(int i = 1; i <= n; i++)
    for(int j = 1; j <= n/i; j++)
        factor[i*j].push_back(i);
for(int i = 1; i <= n; i++) //输出
{
    for(int j = 0; j < factor[i].size(); j++)
        printf("%d",factor[i][j]);
    puts("");
}

推论:1~N每个数的约数个数的总和大约为NlogN

反素数

1_{N中最大的反质数就是1}N中约数个数最多的数中最小的一个

1~N中任何数的不同质因子都不会超过10个,且所有质因子的指数总和不超过30(根据质数相乘得来)

原因:如果不是这样的话,那必然会存在比其更小的具有相同约数个数的数字

方法:使用深度优先搜索,尝试依次确定各个质数的指数,并满足上述条件(指数单调递减,总乘积不超过N),同时记录约数个数

#include <bits/stdc++.h>
using namespace std;
int sushu[10] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
int yueshu;
int ans;
int n;
void dfs(int now, int cishu, int num, int yue_num) //深度优先搜索
{
    if (yue_num > yueshu || yue_num == yueshu && num < ans)
    {
        yueshu = yue_num;
        ans = num;
    }
    if (now >= 10)
        return;
    for (int i = 1; i <= cishu; i++) // 从1到最大次数,依次遍历该项质数的指数,并递归
    {
        if ((long long)num * sushu[now] > n)
            break;
        num *= sushu[now];
        dfs(now + 1, i, num, yue_num * (i + 1));//(这里的约数个数参考上面的算法基本定理的推论)
    }
}
int main()
{
    cin >> n;
    dfs(0, 30, 1, 1); // 从0开始,30为最大值,1是数本身,1是约数个数
    cout << ans << endl;
    return 0;
}

余数之和(O(sqrt(K)))

k mod i = k - floor(k/i)*i

等差数列求和公式

#include<bits/stdc++.h>
using namespace std;
long long n,k,ans;
int main()
{
    cin >> n>> k;
    ans = n * k; // 这里先把公式里的"k-"放在这里
    for(int x = 1, gx;x <= n; x = gx + 1)
    {
        gx = k/x ? min(k/(k/x), n) : n; // 这里,正常来说就是k/(k/x),但要考虑到n大于k的情况,那时,x就会大于k,以及考虑最后一个的情况,也就是要尾项为n
        ans -= (k/x) * (x + gx) * (gx - x + 1) / 2;//这里,(k/x)*x为首项,(k/x)*gx为尾项,(gx-x+1)为项数,通过套用等差数列求和公式可得上式
    }
    cout << ans;
}

最大公约数

定义

a和b的公约数中最大的一个,称为a和b的最大公约数,记为gcd(a,b)

a和b的公倍数中最小的一个,称为a和b的最小公倍数,记为lcm(a,b

定理

九章算术.更相减损术(主要在高精度时使用)

欧几里得算法(O(log(a+b)))

(这个欧几里得算法,其实就是相当于上面更相减损术里,一直用第一个公式的第一个等号,一直减到a<b为止)

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

Hankson的趣味题

首先,根据lcm(b,x)=d得出x一定是d的约数,但通过试除法求出d的所有约数时间过长

考虑到n次询问均在2 *1e9范围内,选择预处理出1~sqrt(2 *1e9)的所有质数,然后通过递归深搜算法,得到d1的所有约数,再进行判定

这道题,还卡int,如果用int的话只能过6/11(别问我怎么知道的)

#include <bits/stdc++.h>
using namespace std;
long long ans; // 答案展示
long long n, a0, a1, b0, b1; // 题目要求
long long v[200000];//在用埃氏筛法得到2~sqrt(2e9)时用到的数组
vector<long long> sushu, sushu_t;
vector<long long> cnt, cnt_t;//sushu是存埃氏筛法的结果,_t则是,存每次询问中d1对应的素数及其数量
long long gcd(long long a, long long b)//求最大公约数版子
{
    return b ? gcd(b, a % b) : a;
}
bool jisuan(long long val)//判断是否符合条件
{
    if (gcd(val, a0) == a1 && val * b0 / gcd(val, b0) == b1)//根据最大公约数定理,可得a*b/gcd(a,b)=lcm(a,b)
        return true;
    return false;
}
void dfs(long long now, long long val)//now指当前递归到第几个素数,val指,前面叠加的结果
{
    if (now == sushu_t.size())//当递归结束时的判定
    {
        // cout << val << '\n';
        if (jisuan(val))
            ans++;
        return;
    }
    long long t = 1;
    for (long long i = 0; i <= cnt_t[now]; i++)
    {
        dfs(now + 1, val * t);
        t *= sushu_t[now];
        //       cout << t << '\n';
    }
}
int main()
{
    n = sqrt(2000000000);//这里,懒得定义一个变量了,直接用的n,反正换不换都没影响
    for (long long i = 2; i < n; i++)//埃氏筛法
    {
        if (v[i])
            continue;
        sushu.push_back(i);
        for (long long j = i; j <= n / i; j++)
            v[i * j] = i;
    }
    cnt.resize(sushu.size());
    cin >> n;
    while (n--)
    {
        ans = 0;
        cin >> a0 >> a1 >> b0 >> b1; // x是b1的约数
        long long t = b1;
        sushu_t.clear();
        cnt_t.clear();
        sushu_t.resize(0);
        cnt_t.resize(0);//这两个resize没什么用,当时debug的时候,有病乱投医
        for (long long i = 0; i < sushu.size(); i++)
        {
            cnt[i] = 0;
            while (t % sushu[i] == 0)
            {
                t /= sushu[i];
                cnt[i]++;
            }
            if (cnt[i])
            {
                //cout << sushu[i] << ' ' << cnt[i] << '\n';
                sushu_t.push_back(sushu[i]);
                cnt_t.push_back(cnt[i]);
            }
        }//这个for循环是为了得到d1对应的素数及其数量
        // for (long long i = 0; i < sushu_t.size(); i++)
        //     cout << sushu_t[i] << ' ' << cnt_t[i] << '\n';
        if (t != 1)
        {
            sushu_t.push_back(t);
            cnt_t.push_back(1);
        }//这里,额,我也不知道有没有用,但,不确定,美称,增加鲁棒性(反正加了也无所谓)
        dfs(0, 1);//初始状态的深搜
        cout << ans << '\n';
    }
}

(第二种解法看着好复杂,不看了(dog))

互质与欧拉函数

定义

互质

欧拉函数

int phi(int n)
{
    int ans = n;
    for(int i = 2; i <= sqrt(n); i++)
        if(n % i == 0)
        {
            ans = ans / i * (i - 1);
            while(n % i == 0) n/= i;
        }
    if(n > 1) ans = ans / n * (n - 1);
    return ans;
}

积性函数

如果当a,b互质时,有f(ab)=f(a)*f(b),那么称函数f为积性函数

Visible Lattice Points

分析易得，除了（1,0），（0,1）和（1,1）这三个钉子外，一个钉子（x，y）能被看到，当且仅当x！=y且gcd(x,y)=1(当x==y时,与(1,1)在同一条直线上,当gcd(x,y)!=1时,则该钉子与(x/gcd(x,y),y/gcd(x,y)))对应钉子在同一条直线上

因为钉子关于x = y这条直线对称,所以可以只考虑其中一半

#include<bits/stdc++.h>
using namespace std;
int phi[1005];
int n,t;
//结合埃氏筛法以及欧拉函数定义式
void euler(int n)
{
    for(int i = 2; i <= n; i++) phi[i] = i;//初始化赋值
    for(int i = 2; i <= n; i++)
        if(phi[i] == i)//如果i为质数
            for(int j = i; j <= n; j+= i)
                phi[j] = phi[j] / i * (i - 1);//i后的每个数*"((p-1)/p)"
}
int main()
{
    cin >> t;
    for(int i = 1; i <= t; i++)
    {
        cin >> n;
        euler(n);
        int ans = 0;
         for(int i = 2; i <= n; i++)
            ans += phi[i];
        ans *= 2;
        ans += 3;
        cout << i << ' ' << n << ' ' << ans << endl;
    }
    return 0;
}