bzoj3529(莫比乌斯反演＋离线＋树状数组)

在你以为理解mobus的时候，苦苦想通过化简公式来降低复杂度时，这题又打了我一巴掌。

看来我并没有理解到acmicpc比赛的宗旨啊。

这么多次查询可以考虑离线操作，使用树状数组单点更新。

/**************************************************************
    Problem: 3529
    User: chenhuan001
    Language: C++
    Result: Accepted
    Time:5264 ms
    Memory:8412 kb
****************************************************************/

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
using namespace std;
#define N 100100

long long getpow(int j,int cnt)
{
   return (long long)(pow((double)j, cnt+)-)/(j-);
}

struct Binary_Index_tree
{
    long long a[N+];
    void init()
    {
        memset(a,,sizeof(a));
    }
    //位运算
    int lowbit(int x)
    {
        return x & (-x);
    }

    //修改x这个点，并把所有包含x点的所有点都进行修改
    void modify(int x,int add)
    {
        if(x==) return ;
        while(x<N)
        {
            a[x]+=add;
            x+=lowbit(x);
        }
    }

    //得到[1,x]的和
    long long get_sum(int x)
    {
        //if(x >= N) return 0;
        long long ret=;
        while(x>)
        {
            ret += a[x];
            x-=lowbit(x);
        }
        return ret;
    }

}bt;

struct Case
{
    int id;
    int n,m,a;
}tt[];

struct Link
{
    int i,x;
}g[N+];

long long ans[];

int casecmp(Case t1,Case t2)
{
    return t1.a<t2.a;
}

int linksort(Link l1,Link l2)
{
    return l1.x<l2.x;
}

//－－莫比乌斯反演函数－－//
//说明：利用线性素数筛选顺便求了个mu
//注释部分为求从区间[1,b]和区间[1,d]中取两个数，互质对数O（n^0.5）
//复杂度:O(n)
int mu[N];
//int sum[N];

void mobus()
{
    bool mark[N];
    int prime[N];
    int pcnt=;
    memset(mark,,sizeof(mark));
    mu[] = ;
    for(int i=;i<N;i++)
    {
        if(mark[i] == )
        {
            prime[pcnt++] = i;
            mu[i] = -;
        }
        for(int j=;j<pcnt && i*prime[j]<N;j++)
        {
            int tmp = i*prime[j];
            mark[tmp] = ;
            if( i%prime[j] ==  )
            {
                mu[tmp] = ;
                break;
            }

            mu[tmp] = mu[i]*-;
        }
    }
    //    for(int i=1;i<N;i++)
    //        sum[i] += sum[i-1]+mu[i];
}

long long gaobili(int b,int d)
{
    if(b<=||d<=) return ;
    int m = min(b,d);
    long long ans = ;
    while(m>=)
    {
        int tb = b/( b/m + )+;
        int td = d/( d/m + )+;
        //前进的最大位置
        int tm = max(tb,td);
        ans += (bt.get_sum(m)-bt.get_sum(tm-))*(b/m)*(d/m);
        m = tm-;
    }
    return ans;
}

int main(int argc, const char * argv[]) {

    for(int i=;i<N;i++)
    {
        int tmp = ;
        int ti = i;
        for(int j=;j*j<=ti;j++)
        {
            if(ti%j == )
            {
                int cnt=;
                while(ti%j==)
                {
                    ti /= j;
                    cnt++;
                }
                tmp *= getpow(j,cnt);
            }
        }
        if(ti != )
        {
            tmp *= getpow(ti,);
        }
        g[i].i = i; g[i].x = tmp;
    }
    sort(g+,g+N,linksort);

    int T;
    cin>>T;
    for(int i=;i<T;i++)
    {
        tt[i].id = i;
        scanf("%d%d%d",&tt[i].n,&tt[i].m,&tt[i].a);
    }
    sort(tt,tt+T,casecmp);

    bt.init();
    mobus();

    int j=;
    for(int i=;i<T;i++)
    {
        while(j<N && g[j].x <= tt[i].a)
        {
            int tmp = g[j].i;
            for(int d=tmp;d<N;d += tmp)
            {
                bt.modify(d, g[j].x*mu[d/tmp]);
            }
            j++;
        }
        //然后就是根号n
        ans[tt[i].id] = gaobili(tt[i].m, tt[i].n);
    }

    //for(int i=0;i<T;i++) cout<<ans[i]%(1LL<<31)<<endl;
    long long mod = (1LL<<(31LL));
    for(int i=;i<T;i++) printf("%d\n",(int)(ans[i]&(0x7fffffff)));
    return ;
}