Sum Of Gcd HDU - 4676（莫队）

最新推荐文章于 2019-09-21 21:29:55 发布
最新推荐文章于 2019-09-21 21:29:55 发布
阅读量365 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 莫队算法 GCD 离线处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Coldfresh/article/details/78296589
本文介绍了一种解决区间GCD求和问题的方法，并通过优化减少计算复杂度。使用线性筛法预处理欧拉函数与因数分解，结合分块思想进行区间查询优化。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Given you a sequence of number a 1, a 2, …, 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 1,a 2,…,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
把自己蠢哭了，智障去每次去dfs一个数的因子，直接预处理存起来不就好了嘛，预处理第一个询问居然直接去暴力，对自己无语啊。。。
优化版：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<bitset>
#include<vector>
#define N 20500
#define INF 10000000000
#define mod 1000000007
using namespace std;
typedef long long  ll;
vector<int> factor[20005];
int phi[N];
void init()
{
    for(int i=0;i<N;i++)
        phi[i]=i;
    for(int i=2;i<N;i++)
    {
        if(phi[i]==i)
        {
            for(int j=i;j<N;j+=i)
                phi[j]-=phi[j]/i;
        }
    }
    for(int i=1;i<=20000;i++)
        for(int j=i;j<=20000;j+=i)
        factor[j].push_back(i);

}
int block[N];
struct node
{
    int l,r;
    int index;
}query[N];
ll ans[N];
int a[N];
int cmp(node x1,node x2)
{
    if(block[x1.l]==block[x2.l])
        return x1.r<x2.r;
    return block[x1.l]<block[x2.l];
}
int cnt[N];
int curL,curR;
ll curAns;
void add(int x)
{
    for(int i=0;i<factor[x].size();i++)
        {
            int num=factor[x][i];
            curAns+=phi[num]*cnt[num];
            cnt[num]++;
        }
}
void sub(int x)
{
    for(int i=0;i<factor[x].size();i++)
        {
            int num=factor[x][i];
            cnt[num]--;
            curAns-=phi[num]*cnt[num];
        }
}
void work(int L,int R)
{
    while(curL<L)
    {
        sub(a[curL]);
        curL++;
    }
    while(curL>L)
    {
        curL--;
        add(a[curL]);
    }
    while(curR>R)
    {
        sub(a[curR]);
        curR--;
    }
    while(curR<R)
    {
        curR++;
        add(a[curR]);
    }
}
int main()
{
    init();
    int t,n;
    scanf("%d",&t);
    int cal=1;
    while(t--)
    {
        memset(cnt,0,sizeof(cnt));
        scanf("%d",&n);
        int limit=(int)sqrt(n);
        for(int i=1;i<=n;i++)
            block[i]=(i-1)/limit;
        for(int i=1;i<=n;i++)
            scanf("%d",a+i);
        int m;
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&query[i].l,&query[i].r);
            query[i].index=i;
        }
        sort(query+1,query+1+m,cmp);
        curAns=0;
        for(int i=query[1].l;i<=query[1].r;i++)
            add(a[i]);
        ans[query[1].index]=curAns;
        curL=query[1].l;
        curR=query[1].r;
        for(int i=2;i<=m;i++)
        {
            work(query[i].l,query[i].r);
            ans[query[i].index]=curAns;
        }
        printf("Case #%d:\n",cal++);
        for(int i=1;i<=m;i++)
            printf("%lld\n",ans[i]);
    }
    return 0;
}

智障的版本：

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<bitset>
#include<vector>
#define N 20500
#define INF 10000000000
#define mod 1000000007
using namespace std;
typedef long long  ll;
vector<int> prime;
int phi[N];
void init()
{
    for(int i=0;i<N;i++)
        phi[i]=i;
    for(int i=2;i<N;i++)
    {
        if(phi[i]==i)
        {
            prime.push_back(i);
            for(int j=i;j<N;j+=i)
                phi[j]-=phi[j]/i;
        }
    }
}
int block[N];
struct node
{
    int l,r;
    int index;
}query[N];
int ans[N];
int a[N];
int cmp(node x1,node x2)
{
    if(block[x1.l]==block[x2.l])
        return x1.r<x2.r;
    return block[x1.l]<block[x2.l];
}
int gcd(int a,int b)
{
    return a%b==0?b:gcd(b,a%b);
}
int cnt[N];
int curAns,curL,curR;
int fac[100];
int e[100];
int k;
void getFac(int x)
{
    k=0;
    for(int i=0;prime[i]*prime[i]<=x;i++)
    {
        if(x%prime[i]==0)
        {
            fac[k]=prime[i];
            e[k]=0;
            while(x%prime[i]==0)
            {
                x/=prime[i];
                e[k]++;
            }
            k++;
        }
    }
    if(x>1)
    {
        fac[k]=x;
        e[k]=1;
        k++;
    }
}
int state;
void dfs(int cur,int temp)
{
    if(cur==k)
    {
        //cout<<temp<<endl;
        if(state==0)
        {
            cnt[temp]--;
            curAns-=phi[temp]*cnt[temp];
        }
        else
        {
            curAns+=phi[temp]*cnt[temp];
            cnt[temp]++;
        }
        return ;
    }
    dfs(cur+1,temp);
    int c=temp;
    for(int i=1;i<=e[cur];i++)
    {
        c*=fac[cur];
        dfs(cur+1,c);
    }

}
void dfs2(int cur,int temp)
{
    if(cur==k)
    {
        cnt[temp]++;
        return ;
    }
    dfs2(cur+1,temp);
    int c=temp;
    for(int i=1;i<=e[cur];i++)
    {
        c*=fac[cur];
        dfs2(cur+1,c);
    }

}
void work(int L,int R)
{
    while(curL<L)
    {
        state=0;
        getFac(a[curL]);
        dfs(0,1);
        curL++;
    }
    while(curL>L)
    {
        state=1;
        curL--;
        getFac(a[curL]);
        dfs(0,1);
    }
    while(curR>R)
    {
        state=0;
        getFac(a[curR]);
        dfs(0,1);
        curR--;
    }
    while(curR<R)
    {
        state=1;
        curR++;
        getFac(a[curR]);
        dfs(0,1);
    }
}
int main()
{
    init();
    int t,n;
    scanf("%d",&t);
    int cal=1;
    while(t--)
    {
        memset(cnt,0,sizeof(cnt));
        scanf("%d",&n);
        int limit=(int)sqrt(n);
        for(int i=1;i<=n;i++)
            block[i]=(i-1)/limit;
        for(int i=1;i<=n;i++)
            scanf("%d",a+i);
        int m;
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&query[i].l,&query[i].r);
            query[i].index=i;
        }
        sort(query+1,query+1+m,cmp);
        curAns=0;
        for(int i=query[1].l;i<=query[1].r;i++)
        {
            getFac(a[i]);
            dfs2(0,1);
            for(int j=i+1;j<=query[1].r;j++)
                curAns+=gcd(a[i],a[j]);
        }
        ans[query[1].index]=curAns;
        curL=query[1].l;
        curR=query[1].r;
        for(int i=2;i<=m;i++)
        {
            work(query[i].l,query[i].r);
            //cout<<curL<<" "<<curR<<endl;
            /*for(int i=1;i<=5;i++)
                cout<<cnt[i]<<" ";
            cout<<endl;*/
            ans[query[i].index]=curAns;
        }
        printf("Case #%d:\n",cal++);
        for(int i=1;i<=m;i++)
            printf("%d\n",ans[i]);
    }
    return 0;
}
GCD HDU - 5726 线段树+数学
why932346109的博客
08-10 273
Give you a sequence ofN(N≤100,000)N(N≤100,000)integers :a1,...,an(0<ai≤1000,000,000)a1,...,an(0<ai≤1000,000,000). There areQ(Q≤100,000)Q(Q≤100,000)queries. For each queryl,rl,ryou have to...
HDU-5726-GCD(GCD预处理 + 线段树维护区间)
hddddh的博客
07-13 554
链接: HDU-5726-GCD 题意： 给你n个数（n<=1e5）然后m个询问(m<=1e5)，每个询问一个区间，问你这个区间的GCD是多少，并且输出从1到n有多少个区间的GCD和这个区间的相同。 思路: 第一部分可以用线段树维护区间的GCD，第二部分，我们可以固定一个右端点，找出每一个gcd值变化的左端点，这个区间的长度就是区间gcd出现的次数。类似于递推的思路，具体看代码。 代码: #include <iostream> #include <cstdio> #inc
HDU 4676 Sum Of Gcd【数论，数据结构（分块）】
ithome
08-15 190
静态区间查询，没有更新操作，瞬间就想起来了哪个O(n*sqrt(n))的做法。关键是区间转移的时候不会处理了，只能说数学拙计了…… 对于此类问题的时间复杂度分析，详见：http://blog.youkuaiyun.com/yang_7_46/article/details/9618637 买一送一，之前一场多校的题目的题解给的是树状数组，其实也可以用这个算法水过，时间也挺快。 http://blog.c...
Sum Of Gcd(hdu 4676)
weixin_30778805的博客
11-07 107
Sum Of Gcd Time Limit: 10000/5000 MS (Java/Others)Memory Limit: 65535/32768 K (Java/Others)Total Submission(s): 738Accepted Submission(s): 333 Problem Description Given you a sequen...
[反演 莫队算法] HDU 4676 Sum Of Gcd
雯舞
02-01 463
考虑对一堆数求一个gcd 我们记录每一个约数xx的出现次数num[x]num[x] 那么两两间gcd的和是什么呢 ∑x∗C2num[x]\sum x*C_{num[x]}^2 肯定不是 这样会有重复 猜想f(x)f(x)是关于x的函数 ∑f(x)∗C2num[x]\sum f(x)*C_{num[x]}^2 那么应该满足 ∑d|xf(d)=x\sum_{d|x} f(d)=x 因为
HDU 4676 Sum Of Gcd（莫队+莫比乌斯反演）
无限大な梦のあとの 何もない世の中じゃ
10-28 948
来看答案怎么求？ ∑i=LR∑j=i+1Rgcd(a[i],a[j])=∑i=LR∑j=i+1R∑d|gcd(a[i],a[j])ϕ(d)=∑dϕ(d)∑i=L,d|a[i]R∑j=i+1,d|a[j]R1\sum_{i=L}^R\sum_{j=i+1}^Rgcd(a[i],a[j]) =\sum_{i=L}^R\sum_{j=i+1}^R\sum_{d|gcd(a[i],a[j])}\p
hdu 4676 分块
老李2009
06-20 578
给定一个1-N的全排列序列，N
HDU-6273-Master of GCD（差分数组）
qq_43750980的博客
09-21 351
题目描述 Hakase has n numbers in a line. At fi rst, they are all equal to 1. Besides, Hakase is interested in primes. She will choose a continuous subsequence [l, r] and a prime parameter x each time and ...
HDU 5381 The sum of gcd 询问区间内所有子区间的GCD和 [莫队算法]
Asuna_acmer
09-06 791
预处理+莫队，需要抓住 gcd 的本质。
HDU 5381 The sum of gcd （2015年多校比赛第8场）
Skyline
08-15 2061
1.题目描述：点击打开链接 2.解题思路：本题利用莫队算法解决。由于是第一次学习这个算法，因此研究了比较长的一段时间才弄懂。首先，莫队算法解决的问题是无修改的离线区间查询问题。该算法实际上是由曼哈顿距离最小生成树演变来的，由于要处理m个区间，可以将这m个区间看做二维平面上的点，那么处理这m个区间就等价于让这m点连通，且总的转移代价最小。这其实就是一个曼哈顿距离最小生成树问题。 经典的曼
HDU4676 Sum Of Gcd （数论 + 分块）
Dizzy的专栏
10-07 521
来看答案怎么求？  ∑i=LR∑j=i+1Rgcd(a[i],a[j])=∑i=LR∑j=i+1R∑d|gcd(a[i],a[j])ϕ(d)=∑dϕ(d)∑i=L,d|a[i]R∑j=i+1,d|a[j]R1 后一项就是[L,R]这段区间内有多少个d的倍数。  cnt[d][x]代表前x项中d的倍数的个数。  原式可化为  ∑i=LR∑j=i+1Rgcd(a[i],a
HDU4676 Sum Of Gcd
MakingMaker的专栏
08-15 2053
题意：给定一个n的排列，询问L到R之间任意两个数的gcd之和 以下是解题报告的思路，解题报告看了n久才看懂， 记一下，以免以后忘记了~~ 对于L到R之间的一个数A，如果数A的一个因子B在L到R之间出现了K次，则结果加上K*F[B]。例如4有因子2，出现了K次，加上K*F[2]。 当然A有因子B，则A有B的因子C，又要加上K*F[C]。 假如A有因子2，除去A之外，L到R还有有1个因子2，1个
[数论 反演 && 莫队] hdu4676 . Sum Of Gcd
CE玩家
09-06 592
假设我们知道一个区间内数字 ii 是否出现，另它为 bib_i 推一推 ∑i=1n∑j=1ngcd(i,j)×bi×bj\sum_{i=1}^{n}\sum_{j=1}^ngcd(i,j)\times b_i\times b_j=∑Tf(T)(∑T|ibi)2=\sum_Tf(T)(\sum_{T|i}b_i)^2其中f(T)=∑d|Td×μ(Td)f(T)=\sum_{d|T}d\times
【HDU4676】Sum Of Gcd-莫队算法+欧拉函数
Maxwei_wzj的OI世界
02-23 341
测试地址：Sum Of Gcd 题目大意：给定一个111~nnn的全排列AAA，若干个询问，每次询问给出一个区间[l,r][l,r][l,r]，要求得出∑l≤i&lt;j≤rgcd(Ai,Aj)∑l≤i&lt;j≤rgcd(Ai,Aj)\sum_{l\le in=∑d|nφ(d)n=∑d|nφ(d)n=\sum_{d|n}\varphi(d) 那么有： ∑l≤i&lt;j≤rgcd(Ai,A...
[莫比乌斯反演+莫队] HDU4676 Sum Of Gcd
Lynstery's blog
09-28 518
反演的过程类似这题 ，得 ∑T=1nϕ(T) cnt[T]2 \sum_{T=1}^n \phi(T)\ cnt[T] ^2 cnt[T]cnt[T] 表示当前区间内是 TT 的倍数的数的个数。 因为有 cntcnt，每次直接求肯定不行，可以想到莫队。移动过程中每次暴力维护 cntcnt 即可。 复杂度理论很大，但实际上能过。#include<cstdio> #include<cmath>
hdu4676 Sum Of Gcd
单木的专栏
07-13 508
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4676题目大意：∑Ri=L∑Rj=i+1gcd(a[i],[j])\sum_{i=L}^{R}\sum_{j=i+1}^{R}gcd(a[i],[j])解题思路：用莫队算法优化，同时用到一个技巧：一个数n与一个集合中每个数的最大公约数的和=∑d∣nphi(d)∗num(d)=\sum_{d\mid n}p
hdu4676 ------麦比乌斯反演&&分块
coding my life
08-18 2151
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4676 解题思路：总体上这是一个数学题加上离线与分块处理加速。显然对于区间内有公约数x的数来说，假设有num[x]个x的倍数，那么答案显然是sigma(C(num[x],2)*f(x))，根据容斥原理f(x)应该是一个小于x的数并且满足sigma(f(d)) = x{d|x}，因为有x这个约数
HDU 4676 Sum Of Gcd（分组）
weixin_33895516的博客
01-08 395
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4676 题意：给出一个n的数列A，A的元素为1到n的一个排列。若干询问。每次查询区间[L,R]，输出： 思路：设区间[L,R]内所有数字中有num[d]个数字有因子d，那么直观上想的话我们觉得答案应该加上： 因为这num[d]个数中每两个数的Gcd都有可能是d。但是这样又是不对的，比如区间...
HDU - 4676 Sum Of Gcd 莫比乌斯+莫队
I good vegetable a!
02-22 998
题目链接 : 点这里 题意：给了一个数列a，然后给了一个区间[L, R]，然后要求 sigma(gcd(i, j)), L <= i < j <= R。 解题方法： 令g(l, r) = sigma(gcd(i, j)), L <= i < j <= R.举个栗子，当a[L:R] = {4, 5, 8}时， 答案是1 + 1 + 4 = 6。由于最大公约数本身的定义，我们可以猜想多个数的gcd
hdu-api：覆盖教务管理与一卡通服务的Python SDK
标题中提到的"hdu-api"是一个SDK（软件开发工具包），它专门为了与哈尔滨工业大学（HDU）的教务系统进行交互而设计。SDK全称为Software Development Kit，是一套为了帮助开发者构建软件而提供的工具和文档的集合。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值