* 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 = ;
 #define ll long long
 int mu[MAXN+] , prime[MAXN/] , g[MAXN+] , sum[MAXN+];
 bool check[MAXN+];
 int tot;

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

 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 = ;
         int la=;
         for(int s= ; s<=n ; s=la+){
             //这里分块的意思很明显，因为在一个区间内，n/s ,m/s 的取值是不会变的，所以我们不用连续计算
             la = min(n/(n/s) , m/(m/s));
             ans = ans + (ll)(n/s)*(m/s)*(sum[la]-sum[s-]);
         }
         printf("%lld\n" , ans);
     }
     return ;
 }