[BZOJ3529]数表

假设$n\leq m$，我们先不考虑$\leq a$的限制

$\sum\limits_{i=1}^n\sum\limits_{j=1}^m\sigma((i,j))=\sum\limits_{T=1}^n\left\lfloor\frac nT\right\rfloor\left\lfloor\frac mT\right\rfloor\sum\limits_{d|T}\sigma(d)\mu\left(\frac Td\right)$

我们可以线性筛出$g(n)=\sum\limits_{d|n}\mu(d)\mu\left(\frac nd\right)$并$O(\sqrt n)$回答询问

现在加上了$\leq a$的限制，其实就是只计算$\sigma(d)\leq a$的$d$

考虑离线，把所有询问按$a$排序，按$\sigma(d)$从小到大更新$g$（更新$d$的倍数处的$g$）就可以做了

用树状数组维护$g$，时间复杂度$O\left(n\log_2^2n+q\sqrt n\log_2n\right)$

#include<stdio.h>
#include<algorithm>
using namespace std;
typedef long long ll;
const int T=100000;
int pr[T+10],mu[T+10],d[T+10],sd[T+10];
bool np[T+10];
void sieve(){
	int i,j,M;
	M=0;
	mu[1]=1;
	d[1]=1;
	sd[1]=1;
	for(i=2;i<=T;i++){
		if(!np[i]){
			pr[++M]=i;
			mu[i]=-1;
			d[i]=i;
			sd[i]=i+1;
		}
		for(j=1;j<=M&&i*pr[j]<=T;j++){
			np[i*pr[j]]=1;
			if(i%pr[j]==0){
				d[i*pr[j]]=d[i]*pr[j];
				sd[i*pr[j]]=sd[i/d[i]]*(sd[d[i]]*pr[j]+1);
				break;
			}
			mu[i*pr[j]]=-mu[i];
			d[i*pr[j]]=pr[j];
			sd[i*pr[j]]=sd[i]*sd[pr[j]];
		}
	}
}
int s[100010];
int lowbit(int x){return x&-x;}
void add(int x,int d){
	while(x<=T){
		s[x]+=d;
		x+=lowbit(x);
	}
}
int query(int x){
	int r=0;
	while(x){
		r+=s[x];
		x-=lowbit(x);
	}
	return r;
}
struct ask{
	int n,m,a,i;
}q[100010];
bool operator<(ask a,ask b){return a.a<b.a;}
int p[100010],ans[100010];
bool cmp(int a,int b){return sd[a]<sd[b];}
#define qn q[i].n
#define qm q[i].m
int main(){
	sieve();
	int m,M,i,j,nex,s;
	scanf("%d",&m);
	for(i=1;i<=m;i++){
		scanf("%d%d%d",&qn,&qm,&q[i].a);
		if(qn>qm)swap(qn,qm);
		q[i].i=i;
	}
	sort(q+1,q+m+1);
	for(i=1;i<=T;i++)p[i]=i;
	sort(p+1,p+T+1,cmp);
	M=1;
	for(i=1;i<=m;i++){
		while(M<=T&&sd[p[M]]<=q[i].a){
			for(j=p[M];j<=T;j+=p[M]){
				if(mu[j/p[M]])add(j,sd[p[M]]*mu[j/p[M]]);
			}
			M++;
		}
		s=0;
		for(j=1;j<=qn;j=nex+1){
			nex=min(qn/(qn/j),qm/(qm/j));
			s+=(qn/j)*(qm/j)*(query(nex)-query(j-1));
		}
		ans[q[i].i]=s;
	}
	for(i=1;i<=m;i++)printf("%d\n",ans[i]&2147483647);
}