* SPOJ PGCD Primes in GCD Table （需要自己推线性筛函数，好题）

题目大意：

给定n，m，求有多少组(a,b) 0<a<=n , 0<b<=m ， 使得gcd（a，b）= p ， p是一个素数

这里本来利用枚举一个个素数，然后利用莫比乌斯反演可以很方便得到答案，但是数据量过大，完全水不过去

题目分析过程（从别人地方抄来的）

ans = sigma(p, sigma(d, μ(d) * (n/pd) * (m/pd)))

Let s = pd, then

ans = sigma(s, sigma(p, μ(s/p) * (n/s) * (m/s)))
    = sigma(s, (n/s) * (m/s) * sigma(p, μ(s/p)))

Let g(x) = sigma(p, μ(x/p)), then

ans = sigma(s, (n/s) * (m/s) * g(s))

如果我们能预处理g(x)的话就能和前面一样分块搞了。这个时候我们多么希望g(x)和μ(x)一样是积性函数。看完题解后，发现有一个不是积性函数，胜似积性函数的性质。由于题解没有给证明，所以就意淫了一个证明。

考虑质数p'，g(p'x) = sigma(p | p'x, μ(p'x/p))。

• 当x % p' == 0，那么考虑sigma中的变量p的所有取值，它和g(x)中p是相同的。而μ(x)这个函数，如果x有平方因子的话就等于0，因此当p != p'时μ(p'x/p) = 0，当p == p'是，μ(p'x/p) = μ(x)。所以g(p'x) = μ(x)。
• 当x % p' != 0，同样考虑p，会发现它的取值只比g(x)中的p多出一个p'。同理按照p是否等于p'讨论，可以得到g(p'x) = -g(x) + μ(x)。

因此g(x)可以在线性筛素数的时候算出。剩下的就是前缀和、分块了。

然后自己看了很久才表示看懂- - ，这里加上自己的理解更加便于阅读

因为我们根据线性筛法得到的莫比乌斯函数，欧拉函数这样的积性函数

所以我们也总是希望上方的g(x)也可以是积性函数方便在线性时间内计算出答案

对于一个积性函数来说，总是不断往前判断它乘上一个素数和当前的联系

列一个素数 p' 那么g(p'x)的结果分析

线性筛的中间过程总是判断当前 i % prime[j] 是否等于 0 ， 所以这里也是判断当前x和p'的整除关系

1.x%p' = 0  , 那么说明x中必然有一个p'的因子 ， 那么sigma(p | p'x, μ(p'x/p)) 中，如果列举的p！=p' , 说明此时 p'*p' | (p'*x/p) ，也就是有至少2个p'的素数因子，所以

mu[p'*x/p] = 0 , 唯一就只要考虑 p 取到 p'的时候  mu[p'*x/p] = mu[x] , 因为其他mu[]都为0->g(p'x)=mu[x]

2.x%p'!=0 , 那么对于先前所有的 x/p 来说，此时乘了p'  , 若p!=p' , 那么因为多了一个因子 mu[p'*x/p] = -mu[x/p] , 所以在p!=p'时，所有的情况相加为-g(x),

在考虑枚举到的p'=p , mu[p'*x/p]  = mu[x] , 所以所有答案叠加所得就是 -g[x]+mu[x]

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int MAXN = 10000000;
#define ll long long
int mu[MAXN+5] , prime[MAXN/10] , g[MAXN+5] , sum[MAXN+5];
bool check[MAXN+5];
int tot;

void getMu(int n)
{
    memset(check , 0 ,  sizeof(check));
    tot=0;
    check[1] = true , mu[1]=1 , g[1]=0;
    for(int i=2 ; i<=n ; i++){
        if(!check[i]) prime[tot++]=i , mu[i]=-1 , g[i]=1;
        for(int j=0 ; j<tot ; j++){
            if(i*prime[j]>n) break;
            check[i*prime[j]]=true;
            if(i%prime[j] == 0){
                mu[i*prime[j]] = 0;
                g[i*prime[j]]=mu[i];
                break;
            }
            else mu[i*prime[j]] = -mu[i] , g[i*prime[j]]=-g[i]+mu[i];
        }
    }
    sum[1]=g[1];
    for(int i=2 ; i<=n ; i++) sum[i]=g[i]+sum[i-1];
}

void swap(int &x , int &y)
{
    int t=x;
    x=y , y=t;
}

int main()
{
   // freopen("a.in" , "r" , stdin);
    getMu(MAXN);
    int T , n , m;
    scanf("%d" , &T);
    while(T--)
    {
        scanf("%d%d" , &n , &m);
        if(n>m) swap(n , m);
        ll ans = 0;
        int la=0;
        for(int s=1 ; s<=n ; s=la+1){
            //这里分块的意思很明显，因为在一个区间内，n/s ,m/s 的取值是不会变的，所以我们不用连续计算
            la = min(n/(n/s) , m/(m/s));
            ans = ans + (ll)(n/s)*(m/s)*(sum[la]-sum[s-1]);
        }
        printf("%lld
" , ans);
    }
    return 0;
}