链接：

#include <stdio.h>
int main()
{
    puts("转载请注明出处[vmurder]谢谢");
    puts("网址：blog.csdn.net/vmurder/article/details/44647001");
}

莫比乌斯反演公式

若$F_n =\sum_{d|n} f_d$
则$f_n = \sum_{d|n} F_{\frac n d}*\mu_d$
其中$\mu$是莫比乌斯函数，跟$F$和$f$无关。

莫比乌斯函数

当$d=1$时：
$\mu_d = 1$
当$d$可以被拆解成$k$个质因数之积且这些质因数两两不同时：
$\mu_d = (-1)^k$
其它情况下：
$\mu_d = 0$

题解：

首先数论题嘛，想到(cha dao)用莫比乌斯反演。
然后很明了了。
我们设$f_{i,j}$为答案函数，也就是gcd==k的数对的个数。
那么$F$就也出来了，根据莫比乌斯反演公式那个破形式，就是gcd是k的倍数的数对的对数。（当然其实很多时候都是发现$F$很好求，并且导到$f$的形式符合莫比乌斯函数，才会去用。但是有的时候不妨去看答案函数作为$f$时$F$是什么，然后看$F$是否好求）
然后$F_{i,j}$很好求，就是$\lfloor \frac i k \rfloor * \lfloor \frac j k \rfloor$。。之后反演回去可以线性得到$f_{i,j}$

但是这样期望很快，不过当$k==1$时，回代将是$O(n)$的，因为好多组询问，所以无法承受。

这时我们发现回代时对于某些${i,j}$，它的$F$是相同的，而这个“相同”，剩下的不相同的数，是根号级别的。然后我们可以分块处理相同的部分，$F*\mu$就变成了一段段的$F*sum\mu$

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define N 101000
#define inf 0x3f3f3f3f
using namespace std;
int mu[N],prime[N],cnt;
bool vis[N];

int sum_of_mu[N];
void shake()
{
    int i,j;
    sum_of_mu[1]=mu[1]=1;
    for(i=2;i<N;i++)
    {
        if(!vis[i])
        {
            mu[i]=-1;
            prime[++cnt]=i;
        }
        for(j=1;i*prime[j]<N&&j<=cnt;j++)
        {
            vis[i*prime[j]]=true;
            if(i%prime[j])mu[i*prime[j]]=-mu[i];
            else break;
        }
        sum_of_mu[i]=sum_of_mu[i-1]+mu[i];
    }
}
int k;
long long calc(int n,int m)
{
    n/=k,m/=k;
    long long ret=0;
    int i,j,lim=min(n,m);
    for(i=1;i<=lim;i=j+1)
    {
        j=min(n/(n/i),m/(m/i));
        ret+=(long long)(n/i)*(m/i)*(sum_of_mu[j]-sum_of_mu[i-1]);
    }
    return ret;
}
inline long long Calc(int a,int b,int c,int d)
{return calc(b,d)-calc(a-1,d)-calc(b,c-1)+calc(a-1,c-1);}
int main()
{
    shake();
    int a,b,c,d,g;
    for(scanf("%d",&g);g--;)
    {
        scanf("%d%d%d%d%d",&a,&b,&c,&d,&k);
        printf("%lld\n",Calc(a,b,c,d));
    }
    return 0;
}