HH的项链 —— 主席树做法

题面

传送门

思路

这道题要问区间内数字的种类数，和我们板子中主席树解决区间某个数出现的次数不同；

因此我们需要转化一下再套板子；

---

首先考虑这样一个结论；

对于询问的区间$[L,R]$，如果某个数字出现了多次，因为我们只能计算一次；

那么我们只关心最右边的这个数字(记为$u$)；

举个例子，比如当前询问的区间为$[1,2,3,1]$；

编号为$1$的这个$1$将被编号为$4$的这个$1$取代，我们只需要考虑编号为$4$的这个$1$的贡献；

因为我们如果要算编号为$1$的贡献，我们发现我们完全可以用编号为$4$的这个数的贡献来代替；

---

我们设$next[i]$表示在这个点之后最近的颜色相同的点;

如果没有就设为$n+1$

---

有了以上结论，区间查询$[L,R]$的颜色种数;

其实就是求所有满足$(L<=i<=R,next[i]>R)$的个数

现在问题就转化成了给定一个区间$[L,R]$求大于某个数的元素个数；

这样就可以套主席树的板子了；

---

代码中head,nex就是为了形成一条链；

Code

#include <iostream>
#include <cstdio>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 1e6 + 10;

int n,a[N],q,cnt,root[N];

int head[N],nex[N];

struct Tree{
    int lc,rc;
    int sum;
}tr[N<<5];

int build(int l,int r){
    int p = ++cnt;
    if(l == r) return p;
    int mid = (l+r) >> 1;
    tr[p].lc = build(l,mid);
    tr[p].rc = build(mid+1,r);
    return p;
}
int update(int p,int l,int r,int val,int k){
    int q = ++cnt;
    tr[q] = tr[p];
    if(l == r){
        tr[q].sum += k;
        return q;
    }
    int mid = (l+r) >> 1;
    if(val <= mid) tr[q].lc = update(tr[p].lc,l,mid,val,k);
    else tr[q].rc = update(tr[p].rc,mid+1,r,val,k);
    tr[q].sum = tr[tr[q].lc].sum + tr[tr[q].rc].sum;
    return q;
}
//找出大于val的值一共是多少
int query(int p,int q,int l,int r,int val){
    if(l == r) return 0;
    int mid = (l+r) >> 1;
    //如果去左树，那么右树肯定都是满足的
    if(val <= mid) return tr[tr[q].rc].sum - tr[tr[p].rc].sum
    + query(tr[p].lc,tr[q].lc,l,mid,val);
    return query(tr[p].rc,tr[q].rc,mid+1,r,val);
}

int read(){
    int x=0;bool f=0;char c=getchar();
    while (c<'0'||c>'9'){if (c=='-')f=1;c=getchar();}
    while (c>='0'&&c<='9'){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
    return f?-x:x;
}
inline void write(int x){
    if(x<0) putchar('-'),x=-x;
    if(x>9) write(x/10);
    putchar(x%10+'0');
}

void solve(){
    n = read();
    for(int i=1;i<=n;++i){
        a[i] = read();
        //形成一条链
        if(head[a[i]]) nex[head[a[i]]] = i;
        head[a[i]] = i;
    }
    for(int i=1;i<=n;++i)
        if(!nex[i]) nex[i] = n + 1; //保证有贡献
    root[0] = build(1,n+1);
    for(int i=1;i<=n;++i){
        root[i] = update(root[i-1],1,n+1,nex[i],1);
    }
    q = read();
    int l,r,res;
    while(q--){
        l = read(),r = read();
        res = query(root[l-1],root[r],1,n+1,r);
        write(res);
        putchar('\n');
    }
}

int main(){
    solve();
    return 0;
}