HDU 6868：Absolute Math（莫比乌斯反演 + 离线暴力）

---

$f(n)=\sum _{d|n}\mu (d{)}^2$，根据 $\mu (d)$ 的定义，当 $d$ 的质因子的幂次不高于一次时有贡献，设 $d$ 的质因子共有 $w(d)$ 种，$f(n)=\sum _{d|n}\mu (d{)}^2=\sum _{i=0}^{w(d)}C(w(d),i)=2^{w(d)}$。

容易发现 $f(n)$ 是一个积性函数。$\sum _{i=1}^{m}f(ni)=f(n)\sum _{i=1}^m\frac{f(i)}{f(gcd(n,i))}$。 接下来推导式子：
$$\sum _{i=1}^m\frac{f(i)}{f(gcd(n,i))}=\sum _{d|n}\frac{1}{f(d)}\sum _{i=1}^{\lfloor \frac{m}{d}\rfloor }f(id)\ast [gcd(\frac{n}{d},i)=1]$$
$$\sum _{d|n}\frac{1}{f(d)}\sum _{t|\frac{n}{d}}\mu (t)\sum _{i=1}^{\lfloor \frac{m}{t\ast d}\rfloor }f(i\ast t\ast d)$$
令 $T=t\ast d$ $$\sum _{T|n}\sum _{d|T}\frac{1}{f(d)}\ast \mu (\frac{T}{d})\sum _{i=1}^{\lfloor \frac{m}{T}\rfloor }f(i\ast T)$$
令 $g(T)=\sum _{d|T}\frac{1}{f(d)}\ast \mu (\frac{T}{d})$，得到：
$$\sum _{T|n}g(T)\sum _{i=1}^{\lfloor \frac{m}{T}\rfloor }f(i\ast T)$$
观察 $g(T)$，$g(T)$ 显然是一个积性函数，可以用欧拉筛预处理。
$g(p)$ 显然为 $\frac{1}{2}-1=-\frac{1}{2}$
$g(p^k)$ 显然为 $\frac{1}{2}-\frac{1}{2}=0$
由此可以观察到， $g(T)$ 只有在 $T$ 的最高幂次不大于 1 的情况下不为 0，对于 $n$ 的因子 T，只需要枚举其质因子的组合即可，由于 $n\le 10^7$，枚举质因子复杂度约为 $8\ast 2^8$

考虑离线暴力计算 $\sum _{i=1}^{\lfloor \frac{m}{T}\rfloor }f(i\ast T)$，将每一组询问枚举质因子组合并将子询问维护到数列中，对子询问排序离线计算。 每种质因子组合 p 最多计算一次 $\frac{m}{p}$，复杂度和调和级数比较接近，约为 $n\log n$

总复杂度为 $O(n\log n+T(\log n+8\ast 2^8))$

---

代码：

#include
using namespace std;
const int maxn = 1e7 + 10;
const int mod = 1e9 + 7;
typedef long long ll;
bool ispri[maxn];
int f[maxn], g[maxn], inv2 = (mod + 1) / 2, n ,m, pri[maxn], t, mindiv[maxn], ans[maxn];
vector<int> p;
struct node {
     
	int n, T, m, id;
	node() {
     }
	node(int ni,int Ti,int mi,int idi) {
     
		n = ni;
		T = Ti;
		m = mi;
		id = idi;
	}
	bool operator < (const node &rhs) const{
     
		if (T != rhs.T) return T < rhs.T;
		return m < rhs.m;
	}
};
vector<node> q;
void sieve(int n) {
     
    ispri[0] = ispri[1] = true;
    pri[0] = 0; f[1] = 1, g[1] = 1, mindiv[1] = 1;
    for (int i = 2; i <= n; i++) {
     
        if (!ispri[i]) {
     
            pri[++pri[0]] = i;
            f[i] = 2;
            g[i] = mod - inv2;
            mindiv[i] = i;
        }
        for (int j = 1; j <= pri[0] && i * pri[j] <= n; j++) {
     
            ispri[i * pri[j]] = true;
            if (i % pri[j] == 0) {
     
                f[i * pri[j]] = f[i];
                mindiv[i * pri[j]] = mindiv[i];
                break;
            } else {
     
                mindiv[i * pri[j]] = pri[j];
                f[i * pri[j]] = 2 * f[i];
                g[i * pri[j]] = 1ll * g[i] * g[pri[j]] % mod;
            }
        }
    }
}
int main() {
     
    sieve(10000000);
    scanf("%d",&t);
    int id = 0;
    while (id++, t--) {
     
        scanf("%d%d",&n,&m);
        p.clear();
        int tmp = n;
        while (tmp != 1) {
     
        	if (mindiv[tmp] != mindiv[tmp / mindiv[tmp]])
        		p.push_back(mindiv[tmp]);
        	tmp /= mindiv[tmp];
		}
		int v = p.size();
		for (int i = 0; i < (1 << v); i++) {
     
			int T = 1;
			for (int j = 0; j < v; j++)
				if ((i >> j) & 1) T *= p[j];
			q.push_back(node(n,T,m / T * T,id));
		}
    }
    sort(q.begin(),q.end());
    int T = 0, w = 0, j = 0;
    for (auto it : q) {
     
    	if (it.T != T) {
     
    		T = it.T, j = it.T, w = 0;
		}
		for (; j <= it.m; j += T)
			w = (w + f[j]) % mod;
		ans[it.id] = (ans[it.id] + 1ll * g[T] * w * f[it.n] % mod) % mod;
	}
	for (int i = 1; i < id; i++)
		printf("%d\n",ans[i]);
    return 0;
}