Sum Of Gcd(hdu 4676)

Sum Of Gcd

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 738    Accepted Submission(s): 333

Problem Description

Given you a sequence of number a₁, a₂, ..., a_n, which is a permutation of 1...n.
You need to answer some queries, each with the following format:
Give you two numbers L, R, you should calculate sum of gcd(a[i], a[j]) for every L <= i < j <= R.

 

Input

First line contains a number T(T <= 10),denote the number of test cases.
Then follow T test cases.
For each test cases,the first line contains a number n(1<=n<= 20000).
The second line contains n number a₁,a₂,...,a_n.
The third line contains a number Q(1<=Q<=20000) denoting the number of queries.
Then Q lines follows,each lines contains two integer L,R(1<=L<=R<=n),denote a query.

 

Output

For each case, first you should print "Case #x:", where x indicates the case number between 1 and T.
Then for each query print the answer in one line.

 

Sample Input

1 5 3 2 5 4 1 3 1 5 2 4 3 3

 

Sample Output

Case #1: 11 4 0

 思路：莫比乌兹反演+莫队；

 

然后后面的s（d）就是欧拉函数；

以上参考http://www.ithao123.cn/content-4754688.html；

然后用莫队算法维护下；

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<math.h>
#include<queue>
#include<vector>
#include<stack>
#include<set>
using namespace std;
typedef long long LL;
int ans[100000];
int mul[100000];
typedef struct node
{
    int l;
    int r;
    int id;
} ss;
ss ask[100000];
bool cmp1(node p,node q)
{
    return p.l < q.l;
}
bool cmp2(node p,node q)
{
    return p.r < q.r;
}
bool prime[30000];
int prime_table[30000];
vector<int>vec[30000];
int cnt[20005];
LL answ[30000];
int oula[20005];
void _slove_mo(int n,int m);
int main(void)
{
    int n,m;
    int T;
    int __ca = 0;
    int cn = 0;
    mul[1] = 1;
    int i,j;
    memset(prime,0,sizeof(prime));
    for(i = 0; i <= 20000; i++)
        oula[i] = i;
    for(i = 2; i <= 20000; i++)
    {
        if(!prime[i])
        {
            prime_table[cn++] = i;
            mul[i] = -1;
        }
        for(j = 0; j < cn&&(i*prime_table[j]<=20000); j++)
        {
            if(i%prime_table[j])
            {
                prime[i*prime_table[j]] = true;
                mul[i*prime_table[j]] = -mul[i];
            }
            else
            {
                prime[i*prime_table[j]] = true;
                mul[i*prime_table[j]] = 0;
                break;
            }
        }
    }//printf("%d
",cn);
    for(i = 0; i < cn; i++)
    {
        for(j = 1; j*prime_table[i]<=20000; j++)
        {
            oula[j*prime_table[i]]/=prime_table[i];
            oula[j*prime_table[i]]*=(prime_table[i]-1);
        }
    }
    for(i = 1; i <= 20000; i++)
    {
        for(j = 1; j <= sqrt(i); j++)
        {
            if(i%j==0)
            {
                vec[i].push_back(j);
                if(i/j != j)
                    vec[i].push_back(i/j);
            }
        }
    }scanf("%d",&T);
    while(T--)
    {
        ++__ca; memset(cnt,0,sizeof(cnt));
        scanf("%d",&n);
        for(i = 1; i <= n; i++)
        {
            scanf("%d",&ans[i]);
        }
        scanf("%d",&m);
        for(i = 0; i < m; i++)
        {
            scanf("%d %d",&ask[i].l,&ask[i].r);
            ask[i].id = i;
        }
        sort(ask,ask+m,cmp1);
        int id = 0;
        int ak = sqrt(1.0*n)+1;
        int v = ak;
        for(i = 0; i < m; i++)
        {
            if(ask[i].l > v)
            {
                v += ak;
                sort(ask+id,ask+i,cmp2);
                id = i;
            }
        }
        sort(ask+id,ask+m,cmp2);
        _slove_mo(n,m);
        printf("Case #%d:
",__ca);
        for(i = 0; i < m; i++)
            printf("%lld
",answ[i]);

    }return 0;
}
void _slove_mo(int n,int m)
{
    int i,j;
    LL sum = 0;
    int xl = ask[0].l;
    int xr = ask[0].r;
    for(i = xl; i <= xr; i++)
    {
        for(j = 0; j < vec[ans[i]].size(); j++)
        {   int x = vec[ans[i]][j];
            sum = sum + (LL)oula[x]*(LL)cnt[x];
            cnt[x]++;
        }
    }
    answ[ask[0].id] = sum;
    for(i = 1; i < m; i++)
    {
        while(xl < ask[i].l)
        {
            int y = ans[xl];
            for(j = 0; j < vec[y].size(); j++)
            {
                int x = vec[y][j];
                sum -= (LL)oula[x]*(LL)(--cnt[x]);
            }
            xl++;
        }
        while(xl > ask[i].l)
        {
            xl--;
            int y = ans[xl];
            for(j = 0; j < vec[y].size(); j++)
            {
                int x = vec[y][j];
                sum += (LL)oula[x]*(LL)(cnt[x]++);
            }
        }
        while(xr > ask[i].r)
        {
            int y = ans[xr];
            for(j = 0; j < vec[y].size(); j++)
            {
                int x = vec[y][j];
                sum -= (LL)oula[x]*(LL)(--cnt[x]);
            }
            xr--;
        }
        while(xr < ask[i].r)
        {
            xr++;
            int y = ans[xr];
            for(j = 0; j < vec[y].size(); j++)
            {
                int x = vec[y][j];
                sum += (LL)oula[x]*(LL)(cnt[x]++);
            }
        }
        answ[ask[i].id] = sum;
    }
}