CF671C. Ultimate Weirdness of an Array

n<=200000个<=200000的数问所有的f(i,j)的和，表示去掉区间i到j后的剩余的数字中任选两个数的最大gcd。

数论日常不会。。

先试着计算一个数组：Hi表示f(l,r)<=i的(l,r)的数量。这样答案就是i*(H_i - H_i-1)的和。要求删掉某个区间后剩余的区间的最大gcd，暴力一点，从大到小枚举gcd的值，然后对每个数记Next_i表示如果当前的gcd为<=x，以i节点做l，r能取到的最小值，那么一个gcd值x的H_x就是一个x对应的所有n-Next_i+1的和。

这样要n^2，问题在于没有考虑Next数组的特点。可以发现对每个x，Next数组是不递减的，而从大到小枚举x只会使限制越来越紧，然后使Next_i越来越大，如果能够在x变成x-1时做一些相应的修改就可以节省每次重算Next的时间。

假设一个x的所有倍数的下标是b1,b2,……,b_k，那么当x变成x-1后，[l,r]至少应覆盖k-1个数，所以i>b2时所有的i都要设成n+1表示对后面的H不再有贡献。b1<i<=b2时，至少要覆盖到bk，所以这些Next_i对bk取个Max，然后1<=i<=b1时，Next_i对b_(k-1)取个Max，完成一次修改。每次取H[x]只需要知道所有Next的和。

需要一个线段树。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<stdlib.h>
#include<math.h>
#include<vector>
//#include<iostream>
using namespace std;

int n;
#define maxn 200011
#define LL long long
int a[maxn];
vector<int> s[maxn];

int prime[maxn],lp=0,xiao[maxn];bool notprime[maxn];
void pre(int n)
{
    for (int i=2;i<=n;i++)
    {
        if (!notprime[i]) prime[++lp]=i,xiao[i]=i;
        for (int j=1;j<=lp && 1ll*i*prime[j]<=n;j++)
        {
            xiao[i*prime[j]]=prime[j];
            notprime[i*prime[j]]=1;
            if (!(i%prime[j])) break;
        }
    }
}

int sep[maxn],lsep,numofsep[maxn];
void dfs(int cur,int num,int idx)
{
    if (cur>lsep) {s[num].push_back(idx);return;}
    dfs(cur+1,num,idx);
    for (int i=1,tmp=sep[cur];i<=numofsep[cur];i++,tmp*=sep[cur]) dfs(cur+1,num*tmp,idx);
}

struct SMT
{
    struct Node
    {
        int ls,rs;
        LL sum,be,Max,Min;
    }a[maxn<<1];
    int size;
    SMT() {size=0;}
    void up(int x)
    {
        const int &p=a[x].ls,&q=a[x].rs;
        a[x].sum=a[p].sum+a[q].sum;
        a[x].Max=max(a[p].Max,a[q].Max);
        a[x].Min=min(a[p].Min,a[q].Min);
    }
    void build(int &x,int L,int R)
    {
        x=++size;
        if (L==R) {a[x].ls=a[x].rs=0; a[x].sum=a[x].Min=a[x].Max=L; a[x].be=0; return;}
        const int mid=(L+R)>>1;
        build(a[x].ls,L,mid); build(a[x].rs,mid+1,R); up(x);
    }
    void build() {int x;build(x,1,n);}
    int ql,qr; LL v;
    void modmaxsingle(int x,int L,int R,LL v)
    {
        a[x].sum=(R-L+1)*v;
        a[x].Max=a[x].Min=v;
        a[x].be=v;
    }
    void down(int x,int L,int R)
    {
        const int &p=a[x].ls,&q=a[x].rs,mid=(L+R)>>1;
        if (a[x].be) {modmaxsingle(p,L,mid,a[x].be); modmaxsingle(q,mid+1,R,a[x].be); a[x].be=0;}
    }
    void Modmax(int x,int L,int R)
    {
        if (a[x].Min>=v) return;
        if (ql<=L && R<=qr && a[x].Max<=v)
        {
            modmaxsingle(x,L,R,v);
            return;
        }
        down(x,L,R);
        const int mid=(L+R)>>1;
        if (ql<=mid) Modmax(a[x].ls,L,mid);
        if (qr> mid) Modmax(a[x].rs,mid+1,R);
        up(x);
    }    
    void modmax(int L,int R,LL v)
    {
        ql=L; qr=R; this->v=v;
        Modmax(1,1,n);
    }
}t;

LL h[maxn];
int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    pre(200000);
    for (int i=1;i<=n;i++)
    {
        int tmp=a[i];
        lsep=0;
        while (tmp>1)
        {
            if (sep[lsep]!=xiao[tmp]) sep[++lsep]=xiao[tmp],numofsep[lsep]=1;
            else numofsep[lsep]++;
            tmp/=xiao[tmp];
        }
        dfs(1,1,i);
    }
    t.build();
    for (int g=200001;g;g--)
    {
        int size=s[g].size();
        if (size>1)
        {
            t.modmax(s[g][1]+1,n,n+1);
            t.modmax(s[g][0]+1,s[g][1],s[g][size-1]);
            t.modmax(1,s[g][0],s[g][size-2]);
        }
        h[g]=1ll*n*(n+1)-t.a[1].sum;
    }
    LL ans=0;
    for (int i=1;i<=200000;i++) ans+=i*(h[i+1]-h[i]);
    printf("%lld
",ans);
    return 0;
}

set也能写。不会。