数学知识——约数个数

约数

如果一个数$a$除以另一个数$b$的余数为0，即 $a\%b$ == 0, 则$b$是$a$的约数。

试除法判断约数

时间复杂度$O(\sqrt{n})$
一个数的约数是成对出现的，并且一个在$\sqrt{n}$左边，一个在右边，所以只需要枚举到$\sqrt{n}$即可。

void get_divisors(int x)
{
    vector<int> res;
    for (int i = 1; i <= x / i; i ++ )
    {
        if (x % i == 0)
        {
            res.push_back(i);
            if (i != x / i) res.push_back(x / i);
        }
    }
    sort(res.begin(), res.end());
    for (auto item : res) cout << item << " ";
    cout << endl;
    return ;
}

约数个数

有一个数$N$,可以进行质因数分解：$N=p_1^{{\alpha }_1}{p}_2^{{\alpha }_2}{p}_3^{{\alpha }_3}...p_k^{{\alpha }_k}$。任何一个约数可以表示成$d=p_1^{{\beta }_1}{p}_2^{{\beta }_2}{p}_3^{{\beta }_3}...p_k^{{\beta }_k}{\beta }_i\le {\alpha }_i$。${\beta }_1$有${\alpha }_1+1$种选法，${\beta }_2$有${\alpha }_2+1$种选法，${\beta }_k$有${\alpha }_k+1$种选法，所以约数个数一共有$({\alpha }_1+1)({\alpha }_2+1)({\alpha }_3+1)...({\alpha }_k+1)$种。

unordered_map<int, int> primes;
while(n--){
        cin >> x;
        for(int i = 2;i <= x/i; ++i){
            while(x % i == 0){
                x /= i;
                primes[i] ++;
            }
        }
        if(x > 1) primes[x] ++;
    }
    for(auto i : primes) ans = ans*(i.second + 1) % mod;
    cout << ans;

约数之和

有一个数$N$,可以进行质因数分解：$N=p_1^{{\alpha }_1}{p}_2^{{\alpha }_2}{p}_3^{{\alpha }_3}...p_k^{{\alpha }_k}$。任何一个约数可以表示成$d=p_1^{{\beta }_1}{p}_2^{{\beta }_2}{p}_3^{{\beta }_3}...p_k^{{\beta }_k}{\beta }_i\le {\alpha }_i$。约数之和为$(1+p_1^1+p_1^2+...+p_1^{{\alpha }_1})(1+p_2^1+p_2^2+...+p_2^{{\alpha }_2})...(1+p_k^1+p_k^2+...+p_k^{{\alpha }_k})$。

unordered_map<int, int> primes;

    while (n -- )
    {
        int x;
        cin >> x;

        for (int i = 2; i <= x / i; i ++ )
            while (x % i == 0)
            {
                x /= i;
                primes[i] ++ ;
            }

        if (x > 1) primes[x] ++ ;
    }

    LL res = 1;
    for (auto p : primes)
    {
        LL a = p.first, b = p.second;
        LL t = 1;
        while (b -- ) t = (t * a + 1) % mod;
        res = res * t % mod;
    }

    cout << res << endl;

最大公约数

求两个正整数 $a$ 和 $b$ 的 最大公约数 $d$
则有 $gcd(a,b)=gcd(b,a\%b)$
证明：
设$a\%b=a-k\ast b$ 其中$k=a/b$(向下取整)
若$d$是$(a,b)$的公约数 则知 $d|a$ 且 $d|b$ 则易知 $d|a-k\ast b$ 故$d$也是$(b,a\%b)$ 的公约数
若$d$是$(b,a\%b)$的公约数 则知 $d|b$ 且 $d|a-k\ast b$ 则 $d|a-k\ast b+k\ast b=d|a$ 故而$d$同时整除$a$和$b$ 所以$d$也是$(a,b)$的公约数
因此$(a,b)$的公约数集合和$(b,a\%b)$的公约数集合相同 所以他们的最大公约数也相同
时间复杂度$O(log(a+b))$

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

轻拍牛头

今天是贝茜的生日，为了庆祝自己的生日，贝茜邀你来玩一个游戏．

贝茜让 $N$ 头奶牛（编号 $1$ 到$N$）坐成一个圈。除了 $1$ 号与 $N$ 号奶牛外，i 号奶牛与 $i-1$ 号和 $i+1$ 号奶牛相邻，$N$ 号奶牛与 $1$ 号奶牛相邻。

农夫约翰用很多纸条装满了一个桶，每一张纸条中包含一个 到 1000000 之间的数字。

接着每一头奶牛 $i$ 从桶中取出一张纸条，纸条上的数字用 $A_i$ 表示。

所有奶牛都选取完毕后，每头奶牛轮流走上一圈，当走到一头奶牛身旁时，如果自己手中的数字能够被该奶牛手中的数字整除，则拍打该牛的头。

牛们希望你帮助他们确定，每一头奶牛需要拍打的牛的数量。

即共有 $N$ 个整数 $A_1,A_2,\dots ,A_N$，对于每一个数 $A_i$，求其他的数中有多少个是它的约数。

输入格式
第一行包含整数 $N$。

接下来 $N$ 行，每行包含一个整数$A_i$。

输出格式
共 $N$ 行，第 $i$ 行的数字为第 $i$ 头牛需要拍打的牛的数量。

数据范围
$1\le N\le 10^5,$
$1\le Ai\le 10^6$

输入样例：

5
2
1
2
3
4

输出样例：

2
0
2
1
3

如果直接采用暴力的做法，时间复杂度为$O(N^2)(N为数据规模)$。
考虑对于每一个数，事先存储下来，并且，并且枚举他们的倍数，可以把时间复杂度降到$O(M+M/2+M/3+...+M/N)=O(MlogN)(M为A_i上限)$。

#include 
using namespace std;
const int N = 1000010;
int a[N], sum[N], cnt[N];
int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i ++ )
    {
        cin >> a[i];
        cnt[a[i]] ++ ;
    }
    for (int i = 1; i < N; i ++ )
    {
        if (!cnt[i]) continue;
        for (int j = i; j < N; j += i )
            sum[j] += cnt[i];
    }
    for (int i = 1; i <= n; i ++ )
        cout << sum[a[i]] - 1 << endl;
    return 0;
}

樱花

求方程：

$$\frac{1}{x}+\frac{1}{y}=\frac{1}{n!}$$

的正整数解的组数，答案对 $10^9+7$ 取模。

输入格式

输入只有一行一个整数，表示 $n$。

输出格式

输出一行一个整数表示正整数解的组数模 $10^9+7$ 的值。

输入输出样例 #1

输入 #1

2

输出 #1

3

输入输出样例 #2

输入 #2

1439

输出 #2

102426508

说明/提示

样例 1 解释

共有三个数对 $(x,y)$ 满足条件，分别是 $(3,6),(4,4)$ 和 $(6,3)$。

数据规模与约定

• 对于 $30\%$ 的数据，保证 $n\le 100$ 。
• 对于 $100\%$ 的数据，保证 $1\le n\le 10^6$。

$\frac{1}{x}+\frac{1}{y}=\frac{1}{n!}$

$(x+y)n!=xy$

$x=\frac{yn!}{y-n!}=\frac{(y-n!+n!)n!}{y-n!}=n!+\frac{(n!{)}^2}{y-n!}$

同时又因为$y>n!$，所以$y-n!$一定$>0$，本问题可以转换为求$(n!{)}^2$的约数个数。

#include 
using namespace std;
const int N = 1000010;
const int mod = 1e9 + 7;
typedef long long ll;
int prime[N];
bool st[N];
int n, cnt = 0;
void init(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) prime[cnt ++ ] = i;
        for (ll j = 0; prime[j] * i <= n; j ++ )
        {
            st[i * prime[j]] = 1;
            if (i % prime[j] == 0)break;
        }
    }
}
int main()
{
    cin >> n;
    ll res = 1;
    init(n);
    for(int i = 0; i < cnt; i ++ )
    {
        int p = prime[i];
        ll s = 0;
        for (ll j = p; j <= n; j *= p) s += n / j;
        res = res * (2 * s + 1) % mod;
    }
    cout << res;
    return 0;
}

反素数

对于任何正整数 $x$，其约数的个数记作 $g(x)$。例如 $g(1)=1$，$g(6)=4$。

如果某个正整数 $x$ 满足：$\forall 0<i<x$，都有 $g(x)>g(i)$，则称 $x$ 为反质数。例如，整数 $1,2,4,6$ 等都是反质数。

现在给定一个数 $N$，你能求出不超过 $N$ 的最大的反质数么？

输入格式

一个数 $N$。

输出格式

不超过 $N$ 的最大的反质数。

输入输出样例 #1

输入 #1

1000

输出 #1

840

说明/提示
$1\le N\le 2\times 10^9$

三个关键点：
1.对于反素数分解质因数，一定满足其中大的质数的次数一定不大于前面小的次数的质数，因为如果后者次数大，我们就可以交换前后两者的次数，这样结果不变，但是会得到更小的数。
2.分解质因数后的质数只会是$2,3,5,7,11,13,17,19,21,23$中的数，因为如果再多一个质数，乘积就大于$N$了。
3.次数之和一定不超过30，因为$2^{31}>2\ast 10^9$。

根据以上性质进行深搜。

#include 
using namespace std;
typedef long long ll;
const int N = 2e9 + 10;
int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
int maxd, number;
int n;
void dfs(int u, int last, int p, int s)
{
    if (s > maxd || (s == maxd && p < number))
    {
        maxd = s;
        number = p;
    }
    if (u == 9) return ;
    for (int i = 1; i <= last; i ++ )
    {
        if ((ll) p * primes[u] > n) break;
        p *= primes[u];
        dfs(u + 1, i, p, s * (i + 1));
    }
    return ;
}
int main()
{
    cin >> n;
    // 枚举到哪一个素数，当前素数最大取几个，当前数，当前约数个数
    dfs(0, 30, 1, 1);
    cout << number << endl;
    return 0;
}

Hankson 的趣味题

Hanks 博士是 BT（Bio-Tech，生物技术) 领域的知名专家，他的儿子名叫 Hankson。现在，刚刚放学回家的 Hankson 正在思考一个有趣的问题。

今天在课堂上，老师讲解了如何求两个正整数 $c_1$ 和 $c_2$ 的最大公约数和最小公倍数。现在 Hankson 认为自己已经熟练地掌握了这些知识，他开始思考一个“求公约数”和“求公倍数”之类问题的“逆问题”，这个问题是这样的：已知正整数 $a_0,a_1,b_0,b_1$，设某未知正整数 $x$ 满足：

1. $x$ 和 $a_0$ 的最大公约数是 $a_1$；

2. $x$ 和 $b_0$ 的最小公倍数是 $b_1$。

Hankson 的“逆问题”就是求出满足条件的正整数 $x$。但稍加思索之后，他发现这样的 $x$ 并不唯一，甚至可能不存在。因此他转而开始考虑如何求解满足条件的 $x$ 的个数。请你帮助他编程求解这个问题。

输入格式

第一行为一个正整数 $n$，表示有 $n$ 组输入数据。接下来的$ n$ 行每行一组输入数据，为四个正整数 $a_0,a_1,b_0,b_1$，每两个整数之间用一个空格隔开。输入数据保证 $a_0$ 能被 $a_1$ 整除，$b_1$ 能被 $b_0$ 整除。

输出格式

共 $n$ 行。每组输入数据的输出结果占一行，为一个整数。

对于每组数据：若不存在这样的 $x$，请输出 $0$，若存在这样的 $x$，请输出满足条件的 $x$ 的个数；

输入输出样例 #1

输入 #1

2 
41 1 96 288 
95 1 37 1776

输出 #1

6 
2

说明/提示

【样例解释】

第一组输入数据，$x$ 可以是 $9,18,36,72,144,288$，共有 $6$ 个。

第二组输入数据，$x$ 可以是 $48,1776$，共有 $2$ 个。

【数据范围】

• 对于 $50\%$ 的数据，保证有 $1\le a_0,a_1,b_0,b_1\le 10000$ 且 $n\le 100$。
• 对于 $100\%$ 的数据，保证有 $1\le a_0,a_1,b_0,b_1\le 2\times 10^9$ 且 $n\le 2000$。

如果采用暴力方法，即枚举$b_1$的每个约数，再判断这个约数是否满足条件的话，时间复杂度为$O(T\sqrt{b_1}log{b}_1)$。
考虑先求出$N$以内的所有素数，对于每个$b_1$，分解质因数，dfs得到所有约数，再对于每个约数判断是否合法。
时间复杂度：
1.预处理所有的约数$O(N)$
2.分解质因数，因为已经得到了所有的质数，所以枚举质数即可，不需要枚举到$\sqrt{b_1}$，因此时间复杂度为$O(T\ast \sqrt{b_1}/ln\sqrt{b_1})$
3.平均每个数约数的个数为$log{b}_1$,做判断的时间复杂度为$log{b}_1$，因此对于每个约数判断是否合法的时间复杂度总和为$O(T\ast (log{b}_1{)}^2))$

#include 
#include 
#include 
using namespace std;
#define N 500010
struct Data{
    int p, c;
}factor[N];
int prime[N];
bool st[N];
int divider[N];
typedef long long ll;
//cnt 记录素数个数，cnt2记录一个数可以分解为的不同质因子个数
//cnt3记录一个数的约数个数
int n, cnt = 0, cnt2 = 0, cnt3 = 0;
int a0, a1, b0, b1;
void init(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i])prime[cnt ++ ] = i;
        for (int j = 0; prime[j] * i <= n; j ++ )
        {
            st[i * prime[j]] = 1;
            if (i % prime[j] == 0)break;
        }
    }
}
void divide(int x)
{
    cnt2 = 0;
    for (int i = 0; prime[i] <= sqrt(x); i ++ )
    {
        int p = prime[i];
        if (x % p == 0)
        {
            int s = 0;
            while (x % p == 0)
            {
                s += 1;
                x /= p;
            }
            factor[cnt2 ++ ] = {p, s};
        }
    }
    if(x > 1) factor[cnt2 ++ ] ={x, 1};
}
void dfs(int u, int p)
{
    if (u == cnt2)
    {
        divider[cnt3 ++ ] = p;
        return ;
    }
    for (int i = 0; i <= factor[u].c; i ++ )
    {
        dfs(u + 1, p);
        p *= factor[u].p;
    }
    return ;
}
int gcd(int x, int y)
{
    return y ? gcd(y, x % y) : x;
}
ll lcm(int x, int y)
{
    return (ll) x * y / gcd(x, y);
}
int main()
{
    init(N - 1);
    cin >> n;
    while(n -- )
    {
        cin >> a0 >> a1 >> b0 >> b1;
        divide(b1);
        cnt3 = 0;
        dfs(0, 1);
        int res = 0;
        for (int i = 0; i < cnt3; i ++ )
        {
            if(gcd(a0, divider[i]) == a1 && lcm(b0, divider[i]) == b1)
            res ++ ;
        }
        cout << res << endl;
    }
    return 0;
}