BZOJ 3529 数表 （莫比乌斯反演+树状数组）*

题目链接：https://cn.vjudge.net/problem/HYSBZ-3529

#include<bits/stdc++.h>
using namespace std;

#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define read(x,y) scanf("%d%d",&x,&y)
#define ll long long

#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
const int  maxn =1e5+5;
const int mod=(1<<31)-1;
ll gcd(ll x,ll y){return y==0?x:gcd(y,x&y);}
ll powmod(ll x,ll y){ll ret;for(ret=1;y;y>>=1,x=x*x) if(y&1) ret=ret*x; return ret;}
/*
题目大意：给定一个矩形数字，设定一个二元函数约数和函数，
求二元矩阵函数约数和之和，要求统计数表中约束和小于a的权值。

先不管限制，把公式化简，老方法枚举gcd。
最终的形式是sigma T:1~n n/T*m/T* sigma d|T F(d)*miu(T/d)。
这时候再考虑限制，想想它要求F函数小于a，
而答案累加的过程中需要累积d|T，所以我们想到，建立一个反射，
F(d)->d,使得在保持F(d)在限制中 时候，可以更新d的倍数来统计答案，
我们先把查询离线并按限制a从小到大排序，然后在结构体中，
建立约束和——d，和d——约束和的映射关系，
有了这个后我们就可以对于满足限制的d，
枚举其倍数，对于倍数的G函数，d都有一次贡献，所以丢到树状数组中。
最终我们用树状数组统计G函数的前缀和
G(T)=sigma d|T F(d)*miu(T/d)。
最后一个小细节就是取模这题可以用与位运算。
*/
///筛法筛莫比乌斯函数和约数和函数
int prim[maxn],tot=0;
int vis[maxn],miu[maxn],s[maxn];
struct dsum
{
    int sd,id;
    bool operator<(const dsum& y) const
    {
        return sd<y.sd;
    }
}d[maxn];
void sieve()
{
    miu[1]=d[1].id=d[1].sd=1;
    for(int i=2;i<maxn;i++)
    {
        d[i].id=i;
        if(vis[i]==0)
        {
            prim[tot++]=i;
            miu[i]=-1;
            d[i].sd=i+1;
            s[i]=1;///最小质因子的幂数
        }
        for(int j=0;j<tot;j++)
        {
            if(1LL*i*prim[j]>=maxn) break;
            int k=i*prim[j];
            vis[k]=1;
            if(i%prim[j])
            {
                miu[k]=-miu[i];
               d[k].sd=d[i].sd*(prim[j]+1);
               s[k]=1;
            }
            else
            {
                s[k]=s[i]+1;
                int tmp=powmod(prim[j],s[i]+1);
                d[k].sd=d[i].sd*(prim[j]-1)/(tmp-1)*(tmp*prim[j]-1)/(prim[j]-1);
                break;
            }
        }
    }
    sort(d+1,d+maxn);
}
///离线询问结构
struct qy
{
    int id,a;
    int n,m;
    bool operator<(const qy& y) const
    {
        return a<y.a;
    }
}q[maxn];
int ans[maxn];
///树状数组结构
int tree[maxn<<1];
int lowbit(int x)
{
    return x&(-x);
}
void add(int x,ll d)
{
    for(;x<maxn;tree[x]+=d,x+=lowbit(x));
}
int sum(int x)
{
    int ret=0;
    for(;x>0;ret+=tree[x],x-=lowbit(x));
    return ret;
}
int main()
{
    sieve();
    ///for(int i=1;i<10;i++) cout<<d[i]<<" ";puts("");
    int t;scanf("%d",&t);
    for(int i=0;i<t;i++)
    {
        scanf("%d%d%d",&q[i].n,&q[i].m,&q[i].a);
        if(q[i].n>q[i].m) swap(q[i].n,q[i].m);
        q[i].id=i;
    }
    sort(q,q+t);   int p=1;
    for(int i=0;i<t;i++)
    {
        while(p<maxn&&d[p].sd<=q[i].a)
        {
            for(int j=1;j*d[p].id<maxn;j++)
                add(j*d[p].id,1LL*d[p].sd*miu[j]);///更新其倍数,根据公式的形式
            p++;
        }
        int ret=0;
        for(int j=1,k;j<=q[i].n;j=k+1)
        {
            k=min(q[i].n/(q[i].n/j),q[i].m/(q[i].m/j));
            int tm=q[i].m/j,tn=q[i].n/j;
            ret+=tm*tn*(sum(k)-sum(j-1));
        }
        ans[q[i].id]=ret&mod;
    }
    for(int i=0;i<t;i++)
    {
        printf("%d\n",ans[i]);
    }
    return 0;
}
/*
1
100000 100000 20000
*/