不正常团伙 （离线线段树 莫队）

不正常团伙 （莫队）

9.27

思路：
std做法。
离线+ 线段树
将询问R 值排序，考虑维护一个数组A，表示当前询问R 值确定，对于每一个L 值答案是多少
假设一直R-1 时的数组A’，我们需要求R 的数组A
预处理处每个位置相同值的上一次出现位置prv[i]。
那么对于A 数组中所有prv[r]+1 到r 的位置，都要加v[r]，因为这些位置到r 的区间v[r] 只出现过1 次。
同理prv[prv[r]]+1 到prv[r] 需要-v[r]
同理prv[prv[prv[r]]]+1 到prv[prv[r]] 需要+3*v[r]
同理1 到prv[prv[prv[r]]] 需要+v[r]
区间修改单点查询，线段树或树状数组都可以。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 101000
#define MAXT MAXN*4
#define MAXQ 101000
#define lch (now<<1)
#define rch (now<<1^1)
#define smid ((l+r)>>1)
typedef long long qword;
int a[MAXN];
int rec[MAXN];
int prv[MAXN];
struct qur_t
{
        int id;
        int x,y;
        qword ans;
}qur[MAXQ];
bool cmp_y(qur_t q1,qur_t q2)
{
        return q1.y<q2.y;
}
bool cmp_id(qur_t q1,qur_t q2)
{
        return q1.id<q2.id;
}
struct sgt_node
{
        qword sum;
        qword pls;
}sgt[MAXT];
void make_plus(int now,int l,int r,qword v)
{
        sgt[now].sum+=v*(r-l+1);
        sgt[now].pls+=v;
}
void down(int now,int l,int r)
{
        if (sgt[now].pls)
        {
                make_plus(lch,l,smid,sgt[now].pls);
                make_plus(rch,smid+1,r,sgt[now].pls);
                sgt[now].pls=0;
        }
}
void Add_sgt(int now,int l,int r,int x,int y,int d)
{
        if (x>y)return ;
        if (l==x && r==y)
        {
                make_plus(now,l,r,d);
                return ;
        }
        down(now,l,r);
        if (y<=smid)
                Add_sgt(lch,l,smid,x,y,d);
        else if (smid<x)
                Add_sgt(rch,smid+1,r,x,y,d);
        else
                Add_sgt(lch,l,smid,x,smid,d),
                        Add_sgt(rch,smid+1,r,smid+1,y,d);
        sgt[now].sum=sgt[lch].sum+sgt[rch].sum;
}
qword Qry_sgt(int now,int l,int r,int pos)
{
        if (l==r)
                return sgt[now].sum;
        down(now,l,r);
        if (pos<=smid)
                return Qry_sgt(lch,l,smid,pos);
        else 
                return Qry_sgt(rch,smid+1,r,pos);
}

int main()
{
        freopen("abnormal.in","r",stdin);
        freopen("abnormal.out","w",stdout);
        int n,m;
        scanf("%d%d",&n,&m);
        for (int i=1;i<=n;i++)
        {
                scanf("%d",a+i);
                prv[i]=rec[a[i]];
                rec[a[i]]=i;
        }
        for (int i=0;i<m;i++)
                scanf("%d%d",&qur[i].x,&qur[i].y),qur[i].id=i;
        sort(qur,qur+m,cmp_y);
        int cc=0;
        for (int i=1;i<=n;i++)
        {
                Add_sgt(1,1,n,prv[i]+1,i,a[i]);
                Add_sgt(1,1,n,prv[prv[i]]+1,prv[i],-a[i]);
                Add_sgt(1,1,n,prv[prv[prv[i]]]+1,prv[prv[i]],3*a[i]);
                Add_sgt(1,1,n,1,prv[prv[prv[i]]],a[i]);
                while (cc<m && qur[cc].y==i)
                {
                        qur[cc].ans=Qry_sgt(1,1,n,qur[cc].x);
                        cc++;
                }
        }
        sort(qur,qur+m,cmp_id);
        for (int i=0;i<m;i++)
                printf("%I64d\n",qur[i].ans);
        return 0;
}

莫队做法就不说了，简单莫队

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#define N 100010
#define LL long long
using namespace std;

int n, m, pos[N], a[N];
LL cnt[N], ans, sum;

struct query{
    int l, r, id;
    LL ans; 
}Q[N];

bool cmp(query a, query b){
    if(pos[a.l] == pos[b.l]) return a.r < b.r;
    return a.l < b.l;
}

bool recmp(query a, query b){
    return a.id < b.id;
}

void update(int p, int add){
    if(cnt[a[p]] == 2) ans += 2LL * a[p];
    cnt[a[p]] += add;
    ans += add * a[p];
    if(cnt[a[p]] == 2) ans -= 2LL * a[p];
}

void solve(){
    for(int i=1,l=1,r=0; i<=m; i++){
        for( ; r<Q[i].r; r++)
            update(r+1, 1);
        for( ; r>Q[i].r; r--)
            update(r, -1);
        for( ; l<Q[i].l; l++)
            update(l, -1);
        for( ; l>Q[i].l; l--)
            update(l-1, 1);
        Q[i].ans = ans;
    }
}

int main(){
    freopen ("abnormal.in", "r", stdin);
    freopen ("abnormal.out", "w", stdout);
    scanf("%d%d", &n, &m);
    for(int i=1; i<=n; i++) scanf("%d", &a[i]);
    int block = int(sqrt(n));
    for(int i=1; i<=n; i++)
       pos[i] = (i-1) / block + 1;
    for(int i=1; i<=m; i++){
        scanf("%d%d", &Q[i].l, &Q[i].r);
        Q[i].id = i;
    }
    sort(Q+1, Q+m+1, cmp);
    solve();
    sort(Q+1, Q+m+1, recmp);
    for(int i=1; i<=m; i++)
        printf("%I64d\n", Q[i].ans);
    return 0;
}