积性函数及其筛法

积性函数及其筛法

前置知识

一些定理

质数筛法 - Cattle_Horse

互质：公约数只有 $1$ 的两个整数叫做互质整数，也称这两个整数互质

算术函数（数论函数）：定义在所有正整数集上的函数称为算术函数（数论函数）

积性函数（乘性函数）：对于任意互质的整数 $a$ 和 $n$ 有性质 $f(a\times b)=f(a)\times f(b)$ 的数论函数

完全积性函数：对于任意整数 $a$ 和 $b$ 有性质$f(a\times b)=f(a)\times f(b)$的数论函数

算术基本定理（唯一分解定理）：任何一个大于 $1$ 的自然数 $N$，如果 $N$ 不为质数，那么 $N$ 可以唯一分解成有限个质数的乘积 $N=P_1^{a_1}{P}_2^{a_2}{P}_3^{a_3}\cdots P_n^{a_n}$，这里 $P_1<P_2<P_3\cdots <P_n$ 均为质数，其中指数 $a_i$ 是正整数。这样的分解称为 $N$ 的标准分解式。

积性函数的重要性质

• 若 $f$ 为积性函数，则 $f(1)=1$
  证明：设 $\mathrm{\forall }n\in {\mathbb{N}}^{\mathbb{+}}$ ，则有 $gcd(n,1)=1$，所以 $f(n)=f(n)\times f(1)$，因此 $f(1)=1$

• （由算术基本定理推得）对于整数 $n$ ，若 $f$ 是积性函数，则$f(n)=f(p_1^{a_1})\times f(p_2^{a_2})\times \cdots \times f(p_n^{a_n})$

• 若 $f(x)$ 和 $g(x)$ 均为积性函数，则以下函数也为积性函数

  • $h(x)=f(x^p)$
  • $h(x)=f^p(x)$
  • $h(x)=f(x)\times g(x)$
  • $h(x)=\sum _{d\mid x}f(d)\times g({\displaystyle \frac{x}{d}})$

常见的积性函数

欧拉函数 $\phi (n)$：在数论中，对于正整数 $n$，欧拉函数是 $1\sim n$ 中与 $n$ 互质的数的个数，即 $\phi (n)=\sum _{x=1}^n[gcd(x,n)=1]$。

莫比乌斯函数 $\mu (i)$：$\mu (n)=\{\begin{array}{ll}1& n=1\\ 0& n\text{ 含有平方因子 }\\ (-1{)}^k& k\text{ 为 }n\text{ 的本质不同质因子个数 }\end{array}$

正整数 $n$ 的约数（正因子）个数 $d(n)$ 或 ${\sigma }_0(n)$：${\sigma }_0(n)=\sum _{d\mid n}1$

正整数 $n$ 的所有约数（正因子）之和 ${\sigma }_1(n)$：${\sigma }_1(n)=\sum _{d\mid n}d$

正整数 $n$ 的所有约数（正因子）$k$ 次幂之和 ${\sigma }_k(n)$：${\sigma }_k(n)=\sum _{d\mid n}{d}^k$

常见的完全积性函数

常函数 $I(n)$：$I(n)=1$

单位函数 $id(n)$：$id(n)=n$

幂函数 $i{d}_k(n)$：$i{d}_k(n)=n^k$

元函数 $ϵ(n)$：$ϵ(n)=[n=1]$

欧拉函数

定义

欧拉函数 $\phi (n)$：在数论中，对于正整数 $n$，欧拉函数是 $1\sim n$ 中与 $n$ 互质的数的个数，即 $\phi (n)=\sum _{x=1}^n[gcd(x,n)=1]$。

性质

性质一

若 $p$ 是质数，则 $\phi (p)=p-1$

证明：

若 $p$ 是质数，则 $p$ 仅有 $p$ 和 $1$ 两个正因子

在 $1\sim p$ 中 ，只有 $p$ 含有正因子 $p$，因此 $\phi (p)=p-1$

性质二

若 $p$ 是质数，则 $\phi (p^k)=(p-1)\times p^{k-1}$

证明（非严谨）：

若 $p$ 是质数，则在 $1\sim p^k$ 中，仅有 $p,2p,3p,\cdots ,p^{k-1}\times p$ 含因子 $p$

因此，$\phi (p^k)=p^k-p^{k-1}=(p-1)\times p^{k-1}$

性质三

欧拉函数是一个积性函数

即 若$gcd(m,n)=1$，则 $\phi (mn)=\phi (m)\phi (n)$

证明略.

计算公式

$\phi (n)=n\times \prod _{i=1}^s(1-{\displaystyle \frac{1}{p_i}})$

注：欧拉函数仅由 $n$ 和其质因子决定，与质因子次数无关

证明（用到以上三个性质及算术基本定理）：

由算术基本定理 $n=\prod _{i=1}^S{p}_i^{{\alpha }_i}=p_1^{{\alpha }_1}{p}_2^{{\alpha }_2}\cdots p_s^{{\alpha }_s}$ 得

$$\begin{array}{rl}\phi (n)& =\prod _{i=1}^S\phi \left(p_i^{{\alpha }_i}\right)\\ & =\prod _{i=1}^s{p}_i^{{\alpha }_i-1}(p_i-1)\\ & =\prod _{i=1}^S{p}_i^{{\alpha }_i}(1-\frac{1}{p_i})\\ & =\prod _{i=1}^S{p}_i^{{\alpha }_i}\times \prod _{i=1}^S(1-\frac{1}{p_i})\\ & =n\times \prod _{i=1}^S\frac{p_i-1}{p_i}\end{array}$$

求单个数的欧拉函数

根据计算公式，通过分解质因子求欧拉函数

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

筛欧拉函数

在线性筛质数的时候，我们提到每个合数 $m$ 都是被其最小的质因子筛去的。

设 $p_j$ 是当前遍历到的质数，则 $m$ 通过 $m=p_j\times i$ 筛去

1. 若 $i$ 能被 $p_j$ 整除，则 $p_j$ 是 $i$ 与 $m$ 的最小质因子，且 $i$ 包含了 $m$ 的所有质因子
   $\phi (m)=m\times \prod _{k=1}^s{\displaystyle \frac{p_k-1}{p_k}}=p_j\times i\times \prod _{k=1}^s{\displaystyle \frac{p_k-1}{p_k}}=p_j\times \phi (i)$
2. 若 $i$ 不能被 $p_j$ 整除，则 $i$ 和 $p_j$ 是互质的
   $\phi (m)=\phi (p_j\times i)=\phi (p_j)\times \phi (i)=(p_j-1)\times \phi (i)$

static int[] primes, phi;
static boolean[] isPrime;
// 求1~n的欧拉函数
static int getPhi(int n) {
    primes = new int[(n + 1) / 2];
    phi = new int[n + 1];
    isPrime = new boolean[n + 1];
    int tot = 0;
    for (int i = 2; i <= n; ++i) isPrime[i] = true;
    phi[1] = 1;//1单独处理
    for (int i = 2; i <= n; ++i) {
        //如果i是质数
        if (isPrime[i]) {
            primes[tot++] = i;
            phi[i] = i - 1;
        }
        for (int j = 0, m; j < tot && (m = i * primes[j]) <= n; ++j) {
            isPrime[m] = false;
            //如果i能被primes[j]整除，则i包含了合数i*prime[j]的所有质因子
            if (i % primes[j] == 0) {
                phi[m] = primes[j] * phi[i];
                break;
            }
            //否则i与primes[j]是互质的
            phi[m] = phi[primes[j]] * phi[i];
            //也可以这么写
            //phi[m]] = (primes[j] - 1) * phi[i];
        }
    }
    return tot;
}

约数（正因子）个数

定义

正整数 $n$ 的约数（正因子）个数 $d(n)$ 或 ${\sigma }_0(n)$：${\sigma }_0(n)=\sum _{d\mid n}1$

计算公式

约数个数定理 - 百度百科

对于正整数 $n$ ，由算术基本定理得：$n=\prod _{i=1}^S{p}_i^{{\alpha }_i}$，则 ${\sigma }_0(n)=\prod _{i=1}^S({\alpha }_i+1)$

注：约数个数只由其质因子次数决定

证明：

$p_i^{{\alpha }_i}$ 的约数有 $p_i^0，p_i^1,\cdots ,p_i^{{\alpha }_i}$ 共 $({\alpha }_i+1)$ 个

由乘法原理（分步乘法）得：${\sigma }_0(n)=\prod _{i=1}^S({\alpha }_i+1)$

求单个数的约数个数

根据计算公式，通过分解质因子求约数个数

static int getSigma0(int n) {
    int ans = 1;
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0) {
            int k = 1;
            while (n % i == 0) {
                ++k;
                n /= i;
            }
            ans *= k;
        }
    }
    if (n > 1) ans *= 2;
    return ans;
}

筛约数个数

记录最小质因子次数

定义 ${\sigma }_0[i]$ 表示 $i$ 的约数个数，$Kth[i]$ 表示 $i$ 的最小质因子的次数（指数）

若 $i$ 是质数，则 $Kth[i]=1$，${\sigma }_0[i]=2$

设 $p_j$ 是当前遍历到的质数，则 $m$ 通过 $m=p_j\times i$ 筛去

1. 若 $i$ 能被 $p_j$ 整除，则 $p_j$ 一定是 $i$ 和 $m$ 的最小质因子，此时 $i$ 与 $m$ 的差别仅为最小质因子次数多 $1$

   ${\sigma }_0[i]=({\alpha }_1+1)\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_s+1)$

   ${\sigma }_0[m]=({\alpha }_1+1+1)\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_s+1)$

   • $Kth[m]=Kth[i]+1$
   • ${\sigma }_0[m]={\sigma }_0[i]÷(Kth[i]+1)\times (Kth[m]+1)={\sigma }_0[i]÷(Kth[i]+1)\times (Kth[i]+2)$
2. 若 $i$ 不能被 $p_j$ 整除，则 $i$ 不含质因子 $p_j$，换言之，$m$ 的最小质因子 $p_j$ 的指数为 $1$
   • $Kth[m]=1$
   • ${\sigma }_0[m]={\sigma }_0[i]\times (1+1)=2\times {\sigma }_0[i]$

static int[] primes, sigma0, Kth;
static boolean[] isPrime;
// 求1~n的约数个数
static int getSigma0(int n) {
    primes = new int[(n + 1) / 2];
    sigma0 = new int[n + 1];
    Kth = new int[n + 1];
    isPrime = new boolean[n + 1];
    int tot = 0;
    for (int i = 2; i <= n; ++i) isPrime[i] = true;
    sigma0[1] = 1;//1单独处理
    for (int i = 2; i <= n; ++i) {
        //如果i是质数
        if (isPrime[i]) {
            primes[tot++] = i;
            Kth[i] = 1;
            sigma0[i] = 2;
        }
        for (int j = 0, m; j < tot && (m = i * primes[j]) <= n; ++j) {
            isPrime[m] = false;
            //如果i能被primes[j]整除，则i包含了合数m的所有质因子
            if (i % primes[j] == 0) {
                Kth[m] = Kth[i] + 1;
                sigma0[m] = sigma0[i] / (Kth[i] + 1) * (Kth[i] + 2);
                break;
            }
            //否则i不含质因子primes[j]
            Kth[m] = 1;
            sigma0[m] = 2 * sigma0[i];
            //也可以这么写
            //sigma0[m] = sigma0[primes[j]] * sigma0[i];
        }
    }
    return tot;
}

不记录最小质因子次数

$Kth[i]$ 最小质因子次数只用于上述情况一求 ${\sigma }_0[m]$

如果不通过 $Kth[i]$ 求 ${\sigma }_0[m]$ ，则可以大大减少运算次数以及所需空间

上述情况一（ $i$ 能被 $p_j$ 整除）：

$\begin{array}{rl}{\sigma }_0[m]& =({\alpha }_1+1+1)\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_s+1)\\ & =2\times ({\alpha }_1+1)\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_s+1)-{\alpha }_1\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_s+1)\\ & =2\times {\sigma }_0[i]-{\alpha }_1\times ({\alpha }_2+1)\times \cdots \times ({\alpha }_s+1)\\ & =2\times {\sigma }_0[i]-{\sigma }_0[{\displaystyle \frac{i}{p_j}}]\end{array}$

static int[] primes, sigma0;
static boolean[] isPrime;
// 求1~n的约数个数
static int getSigma0(int n) {
    primes = new int[(n + 1) / 2];
    sigma0 = new int[n + 1];
    isPrime = new boolean[n + 1];
    int tot = 0;
    for (int i = 2; i <= n; ++i) isPrime[i] = true;
    sigma0[1] = 1;//1单独处理
    for (int i = 2; i <= n; ++i) {
        //如果i是质数
        if (isPrime[i]) {
            primes[tot++] = i;
            sigma0[i] = 2;
        }
        for (int j = 0, m; j < tot && (m = i * primes[j]) <= n; ++j) {
            isPrime[i * primes[j]] = false;
            //如果i能被primes[j]整除，则i包含了合数m的所有质因子
            if (i % primes[j] == 0) {
                sigma0[m] = 2 * sigma0[i] - sigma0[i / primes[j]];
                break;
            }
            //否则i与不含质因子primes[j]
            sigma0[m] = 2 * sigma0[i];
            //也可以这么写
            //sigma0[m] = sigma0[primes[j]] * sigma0[i];
        }
    }
    return tot;
}

约数（正因子）之和

定义

正整数 $n$ 的所有约数（正因子）之和 ${\sigma }_1(n)$：${\sigma }_1(n)=\sum _{d\mid n}d$

计算公式

约数和定理 - 百度百科

对于正整数 $n$ ，由算术基本定理得：$n=\prod _{i=1}^S{p}_i^{{\alpha }_i}$，则 ${\sigma }_1(n)=\prod _{i=1}^S\sum _{j=0}^{{\alpha }_i}{p}_i^j$

求和部分可以使用等比数列求和公式计算

注：约数和只由其质因子及其质因子次数决定

证明：

$p_i^{{\alpha }_i}$ 的约数有 $p_i^0，p_i^1,\cdots ,p_i^{{\alpha }_i}$

则 $p_i^{{\alpha }_i}$ 的约数和为 $\sum _{j=0}^{{\alpha }_i}{p}_i^j$

由乘法原理（分步乘法）得：${\sigma }_1(n)=\prod _{i=1}^S\sum _{j=0}^{{\alpha }_i}{p}_i^j$

例：$12=2^2\times 3^1$，${\sigma }_1(12)=(1+2+4)\times (1+3)=7\times 4=28$

求单个数的约数和

根据计算公式，通过分解质因子求约数和

static int getSigma1(int n) {
    int ans = 1;
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0) {
            int sum = 1, p = 1;
            while (n % i == 0) {
                p *= i;
                sum += p;
                n /= i;
            }
            ans *= sum;
        }
    }
    if (n > 1) ans *= 1 + n;
    return ans;
}

一个数的幂的约数和（暂未经过数据测试）

97. 约数之和 - AcWing题库

即求 ${\sigma }_1(n^k)$

对于正整数 $n$ ，由算术基本定理得：$n=\prod _{i=1}^S{p}_i^{{\alpha }_i}$，则 ${\sigma }_1(n^k)=\prod _{i=1}^S\sum _{j=0}^{{\alpha }_i\times k}{p}_i^j$

证明：

$$\begin{array}{rl}{\sigma }_1(n^k)& ={\sigma }_1((\prod _{i=1}^S{p}_i^{{\alpha }_i}{)}^k)\\ & =\prod _{i=1}^S{\sigma }_1(p_i^{{\alpha }_i\times k})\\ & =\prod _{i=1}^S\sum _{j=0}^{{\alpha }_i\times k}{p}_i^j\end{array}$$

static int getSigma1(int n, int k) {
    int ans = 1;
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0) {
            int index = 0;
            while (n % i == 0) {
                n /= i;
                index += k;
            }
            int sum = 1;
            int p = 1;
            for (int j = 0; j < index; ++j) {
                p *= i;
                sum += p;
            }
            ans *= sum;
        }
    }
    if (n > 1) {
        int sum = 1;
        int p = 1;
        for (int i = 0; i < k; ++i) {
            p *= n;
            sum += p;
        }
        ans *= sum;
    }
    return ans;
}

求和部分可以使用等比数列求和公式 $S_n=a_1\times {\displaystyle \frac{1-q^n}{1-q}}$，则

$${\sigma }_1(n^k)=\prod _{i=1}^S({\displaystyle \frac{p_i^{{\alpha }_i\times k+1}-1}{p_i-1}})$$

求幂部分可以使用快速幂加速求解

static int pow(int a, int b) {
    int ret = 1;
    while (b != 0) {
        if ((b & 1) == 1) ret *= a;
        b >>= 1;
        a *= a;
    }
    return ret;
}
static int getSigma1(int n, int k) {
    int ans = 1;
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0) {
            int index = 1;
            while (n % i == 0) {
                n /= i;
                index += k;
            }
            int sum = (pow(i, index) - 1) / (i - 1);
            ans *= sum;
        }
    }
    if (n > 1) {
        int sum = (pow(n, 1 + k) - 1) / (n - 1);
        ans *= sum;
    }
    return ans;
}

如果使用等比数列求和公式且要取模，则需要求解逆元

筛的约数之和

记录最小质因子的幂的和式

定义 $g[i]$ 表示 $i$ 的最小质因子的幂的和式 ，即$g[i]=\sum _{k=0}^{{\alpha }_i}{p}_j^k$

${\sigma }_1[i]$ 表示 $i$ 的约数和

若 $i$ 是质数，$g[i]={\sigma }_1[i]=i+1$

设 $p_j$ 是当前遍历到的质数，则 $m$ 通过 $m=p_j\times i$ 筛去

1. 若 $i$ 能被 $p_j$ 整除，则 $p_j$ 是 $i$ 和 $m$ 的最小质因子，此时 $m$ 与 $m$ 的差别仅为最小质因子 $p_j$ 的次数多 $1$

   $g[i]=p_j^0+p_j^1+\cdots +p_j^{{\alpha }_j}$

   $g[m]=p_j^0+p_j^1+\cdots +p_j^{{\alpha }_j}+p_j^{{\alpha }_j+1}$

   ${\sigma }_1[i]=g[i]\times \prod _{k=2}^S\sum _{j=0}^{{\alpha }_k}{p}_k^j$

   ${\sigma }_1[m]=g[m]\times \prod _{k=2}^S\sum _{j=0}^{{\alpha }_k}{p}_k^j$

   • $g[m]=p_j^0+p_j^1+\cdots +p_j^{{\alpha }_j}+p_j^{{\alpha }_j+1}=1+p_j\times (p_j^0+p_j^1+\cdots +p_j^{{\alpha }_j})=1+p_j\times g[i]$
   • ${\sigma }_1[m]=g[m]\times \prod _{k=2}^S\sum _{j=0}^{{\alpha }_k}{p}_k^j=g[m]\times {\displaystyle \frac{{\sigma }_1[i]}{g[i]}}$
2. 若 $i$ 不能被 $p_j$ 整除，则 $i$ 不含质因子 $p_j$，换言之，$m$ 的最小质因子 $p_j$ 的指数为 $1$
   • $g[m]=1+p_j$
   • ${\sigma }_1[m]=g[m]\times {\sigma }_1[i]$

static int[] primes, sigma1, g;
static boolean[] isPrime;
// 求1~n的约数和
static int getSigma1(int n) {
    primes = new int[(n + 1) / 2];
    sigma1 = new int[n + 1];
    g = new int[n + 1];
    isPrime = new boolean[n + 1];
    int tot = 0;
    for (int i = 2; i <= n; ++i) isPrime[i] = true;
    sigma1[1] = 1;//1单独处理
    for (int i = 2; i <= n; ++i) {
        //如果i是质数
        if (isPrime[i]) {
            primes[tot++] = i;
            g[i] = sigma1[i] = i + 1;
        }
        for (int j = 0, m; j < tot && (m = i * primes[j]) <= n; ++j) {
            isPrime[m] = false;
            //如果i能被primes[j]整除，则i包含了合数i*prime[j]的所有质因子
            if (i % primes[j] == 0) {
                g[m] = 1 + primes[j] * g[i];
                sigma1[m] = sigma1[i] / g[i] * g[m];
                break;
            }
            //否则i不含质因子primes[j]，即m的最小质因子prime[j]的指数为1
            g[m] = 1 + primes[j];
            sigma1[m] = g[m] * sigma1[i];
            //也可以这么写
            //sigma1[m] = sigma1[primes[j]] * sigma1[i];
        }
    }
    return tot;
}

不记录最小质因子的幂的和式

如果不通过 $g[i]$ 求 ${\sigma }_1[m]$ ，则可以大大减少运算次数以及所需空间

上述情况一（ $i$ 能被 $p_j$ 整除）：

考虑 ${\sigma }_1(i)、{\sigma }_1({\displaystyle \frac{i}{p_j}})$ 与 ${\sigma }_1(m)$ 的关系

令 $T=\prod _{k=2}^S\sum _{j=0}^{{\alpha }_k}{p}_k^j$，则

$$\begin{array}{rlr}{\sigma }_1[i]& =(p_j^0+p_j^1+\cdots +p_j^{{\alpha }_j})\times \prod _{k=2}^S\sum _{j=0}^{{\alpha }_k}{p}_k^j=(p_j^0+p_j^1+\cdots +p_j^{{\alpha }_j})\times T& (1)\\ {\sigma }_1[m]& =(p_j^0+p_j^1+\cdots +p_j^{{\alpha }_j+1})\times \prod _{k=2}^S\sum _{j=0}^{{\alpha }_k}{p}_k^j={\sigma }_1[i]+p_j^{{\alpha }_j+1}\times T& (2)\\ {\sigma }_1[{\displaystyle \frac{i}{p_j}}]& =(p_j^0+p_j^1+\cdots +p_j^{{\alpha }_j-1})\times \prod _{k=2}^S\sum _{j=0}^{{\alpha }_k}{p}_k^j={\sigma }_1[i]-p_j^{{\alpha }_j}\times T& (3)\end{array}$$

将 $p_j\times \left(3\right)+\left(2\right)$，得：

$${\sigma }_1[m]+p_j{\sigma }_1[{\displaystyle \frac{i}{p_1}}]=(p_j+1)\times {\sigma }_1[i]$$

整理，得

$${\sigma }_1[m]=(p_j+1)\times {\sigma }_1[i]-p_j\times {\sigma }_1[{\displaystyle \frac{i}{p_j}}]$$

static int[] primes, sigma1;
static boolean[] isPrime;
// 求1~n的约数和
static int getSigma1(int n) {
    primes = new int[(n + 1) / 2];
    sigma1 = new int[n + 1];
    isPrime = new boolean[n + 1];
    int tot = 0;
    for (int i = 2; i <= n; ++i) isPrime[i] = true;
    sigma1[1] = 1;//1单独处理
    for (int i = 2; i <= n; ++i) {
        //如果i是质数
        if (isPrime[i]) {
            primes[tot++] = i;
            sigma1[i] = i + 1;
        }
        for (int j = 0, m; j < tot && (m = i * primes[j]) <= n; ++j) {
            isPrime[m] = false;
            //如果i能被primes[j]整除，则i包含了合数i*prime[j]的所有质因子
            if (i % primes[j] == 0) {
                sigma1[m] = (1 + primes[j]) * sigma1[i] - primes[j] * sigma1[i / primes[j]];
                break;
            }
            //否则i不含质因子primes[j]，即m的最小质因子prime[j]的指数为1
            sigma1[m] = (1 + primes[j]) * sigma1[i];
            //也可以这么写
            //sigma1[m] = sigma1[primes[j]] * sigma1[i];
        }
    }
    return tot;
}

求连续区间的数的约数和的和

即求 $\sum _{i=l}^r{\sigma }_1(i)$

可不通过筛法求解，而通过数论分块（整除分块）的方法在 $O(\sqrt{r-l+1})$ 的时间复杂度下求解

具体解释见 洛谷 P1403 约数研究 - Cattle_Horse

import java.util.Scanner;

public class Main {
    //计算 1~n 所有约数的和
    static long calculate(long n) {
        long ans = 0;
        for (long l = 1, r; l <= n; l = r + 1) {
            r = Math.min(n / (n / l), n);
            ans += (l + r) * (r - l + 1) / 2 * (n / l);
        }
        return ans;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt(), y = sc.nextInt();
        System.out.println(calculate(y) - calculate(x - 1));
    }
}

约数（正因子）k次幂之和

定义

正整数 $n$ 的所有约数（正因子）$k$ 次幂之和 ${\sigma }_k(n)$：${\sigma }_k(n)=\sum _{d\mid n}{d}^k$

计算公式

对于正整数 $n$ ，由算术基本定理得：$n=\prod _{i=1}^S{p}_i^{{\alpha }_i}$，则 ${\sigma }_k(n)=\prod _{i=1}^S\sum _{j=0}^{{\alpha }_i}{p}_i^{j\times k}$

证明：

对于质数 $p$，$p^{\alpha }$ 的约数有 $p^0,p^1,\cdots ,p^{\alpha }$，则 ${\sigma }_k(p^{\alpha })=\sum _{i=0}^{\alpha }{p}^{i\times k}$

又由算术基本定理及积性函数的性质得：

$$\begin{array}{rl}{\sigma }_k(n)& ={\sigma }_k(\prod _{i=1}^S{p}_i^{{\alpha }_i})\\ & =\prod _{i=1}^S{\sigma }_k(p_i^{{\alpha }_i})\\ & =\prod _{i=1}^S\sum _{j=0}^{{\alpha }_i}{p}_i^{j\times k}\end{array}$$

求单个数的约数（正因子）k次幂之和

根据计算公式，通过分解质因子求约数（正因子）$k$ 次幂之和

幂次部分可以使用快速幂求解

static final int MOD = (int) 1e9 + 7;
static int pow(int a, int b) {
    long ans = 1;
    while (b != 0) {
        if (b % 2 == 1) ans = ans * a % MOD;
        a = a * a % MOD;
        b /= 2;
    }
    return (int) ans;
}
static int getSigmaK(int n, int k) {
    int ans = 1;
    for (int i = 2; i * i <= n; ++i) {
        if (n % i == 0) {
            long sum = 1;
            int index = 0;
            while (n % i == 0) {
                n /= i;
                index += k;
                sum = (sum + pow(i, index)) % MOD;
            }
            ans = (int) ((long) ans * sum % MOD);
        }
    }
    if (n > 1) {
        long sum = (pow(n, k) + 1) % MOD;
        ans = (int) (ans * sum % MOD);
    }
    return ans;
}

筛约数（正因子）k次幂之和

$${\sigma }_k(n)=\prod _{i=1}^S\sum _{j=0}^{{\alpha }_i}{p}_i^{j\times k}$$

定义 $i$ 为当前遍历到的数

若 $i$ 为质数，则 ${\sigma }_k(i)=\sum _{j=0}^1{i}^{j\times k}=i^k+1$

设 $p_j$ 是当前遍历到的质数，$m=i\cdot p_j$

1. 若 $p_j$ 能整除 $i$，则 $p_j$ 是 $i$ 和 $m$ 的最小质因子，即 $m$ 仅是最小质因子 $p_j$ 的指数比 $i$ 多 $1$

   考虑 ${\sigma }_k(i)、{\sigma }_k({\displaystyle \frac{i}{p_j}})$ 与 ${\sigma }_k(m)$ 的关系

   $$\begin{array}{rl}\mathrm{令}T& =\prod _{x=2}^S\sum _{y=0}^{{\alpha }_x}{p}_x^{y\times k}，\mathrm{则}\\ {\sigma }_k(i)& =(\sum _{y=0}^{{\alpha }_1}{p}_j^{y\times k})\times (\prod _{x=2}^S\sum _{y=0}^{{\alpha }_x}{p}_x^{y\times k})=T\times \sum _{y=0}^{{\alpha }_1}{p}_j^{y\times k}& (1)\\ {\sigma }_k({\displaystyle \frac{i}{p_j}})& =(\sum _{y=0}^{{\alpha }_1-1}{p}_j^{y\times k})\times (\prod _{x=2}^S\sum _{y=0}^{{\alpha }_x}{p}_x^{y\times k})={\sigma }_k(i)-T\times p_j^{{\alpha }_1\times k}& (2)\\ {\sigma }_k(m)& =(\sum _{y=0}^{{\alpha }_1+1}{p}_j^{y\times k})\times (\prod _{x=2}^S\sum _{y=0}^{{\alpha }_x}{p}_x^{y\times k})={\sigma }_k(i)+T\times p_j^{{\alpha }_1\times k}\times p_j^k& (3)\end{array}$$

   将 $p_j^k\times (2)+(3)$ 得 ：${\sigma }_k({\displaystyle \frac{i}{p_j}})\times p_j^k+{\sigma }_k(m)=(p_j^k+1)\times {\sigma }_k(i)$

   整理，得：${\sigma }_k(m)=(p_j^k+1)\times {\sigma }_k(i)-{\sigma }_k({\displaystyle \frac{i}{p_j}})\times p_j^k$

   因此需要预处理出 $p_j^k$ 的值，可以使用快速幂求得

2. 若 $p_j$ 不能整除 $i$，则 $p_j$ 与 $i$ 互质，换言之，$m$ 的最小质因子 $p_j$ 的指数为 $1$

   ${\sigma }_k(m)={\sigma }_k(i)\times (p_j^k+1)={\sigma }_k(i)\times {\sigma }_k(p_j)$

   PS：所以它是积性函数

static long pow(long a, int b) {
    long ans = 1L;
    while (b != 0) {
        if (b % 2 == 1) ans = ans * a;
        a = a * a;
        b >>= 1;
    }
    return ans;
}
static int[] primes;
static boolean[] isPrime;
static long[] pk;
static long[] sigmaK;
// 求1~n的约数（正因子）k次幂之和
public static int getSigmaK(final int n, final int k) {
    int len = (int) Math.max((n + 1) / (Math.log(n + 1) - 1.112), 1);
    primes = new int[len];
    isPrime = new boolean[n + 1];
    Arrays.fill(isPrime, true);
    isPrime[0] = isPrime[1] = false;
    pk = new long[n + 1];
    sigmaK = new long[n + 1];
    sigmaK[1] = pk[1] = 1;//1单独处理
    int tot = 0;
    for (int i = 2; i <= n; ++i) {
        if (isPrime[i]) {
            primes[tot++] = i;
            pk[i] = pow(i, k);
            sigmaK[i] = pk[i] + 1;
        }
        for (int j = 0, m; j < tot && (m = i * primes[j]) <= n; ++j) {
            isPrime[m] = false;
            pk[m] = pk[primes[j]];
            if (i % primes[j] == 0) {
                sigmaK[m] = (pk[primes[j]] + 1) * sigmaK[i] - sigmaK[i / primes[j]] * pk[i];
                break;
            }
            sigmaK[m] = sigmaK[i] * (pk[primes[j]] + 1);
            // 也可以这么写
            // sigmaK[m] = sigmaK[i] * sigmaK[primes[j]];
        }
    }
    return tot;
}

参考资料

数论学习笔记1之积性函数与线性筛求积性函数_cqust_qilin02811的博客

积性函数与筛法 - 又又大柚纸

515 筛法求欧拉函数 - 董晓算法

516 筛法求约数个数 - 董晓算法

517 筛法求约数和 - 董晓算法

线性筛约数个数、约数和的新方法 - ldysy2102

约数之和 （数论） - 基地AI

浅谈一类积性函数的前缀和_skywalkert的博客