[SDOI2009]HH的项链解题报告

原题目：洛谷P1972

题目描述

HH 有一串由各种漂亮的贝壳组成的项链。HH 相信不同的贝壳会带来好运，所以每次散步完后，他都会随意取出一段贝壳，思考它们所表达的含义。HH 不断地收集新的贝壳，因此，他的项链变得越来越长。有一天，他突然提出了一个问题：某一段贝壳中，包含了多少种不同的贝壳？这个问题很难回答……因为项链实在是太长了。于是，他只好求助睿智的你，来解决这个问题。

输入输出格式

输入格式：

第一行：一个整数N，表示项链的长度。

第二行：N 个整数，表示依次表示项链中贝壳的编号（编号为0 到1000000 之间的整数）。

第三行：一个整数M，表示HH 询问的个数。

接下来M 行：每行两个整数，L 和R（1 ≤ L ≤ R ≤ N），表示询问的区间。

输出格式：

M 行，每行一个整数，依次表示询问对应的答案。

输入输出样例

输入样例#1：

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

输出样例#1：

2
2
4

说明

数据范围：

对于20%的数据，N ≤ 100，M ≤ 1000；
对于40%的数据，N ≤ 3000，M ≤ 200000；
对于100%的数据，N ≤ 50000，M ≤ 200000。

Solution：

1、暴力大法20分——30分～～，思路就是随你乱搞，随便能想出复杂度O(mn²)，又能想到计数，于是简化到了O(mn)，时间复杂度还是很高，40分都水不了：

 #include<cstdio>
 int a,b,c,d,e,f,i,m,x[]={},w[]={};
 int main()
 {
 scanf("%d",&a);
 c=;
 for(i=;i<=a;i++)
 {
     scanf("%d",&b);
     if(w[b]==)
     {
         c++;
         w[b]=c;
         x[i]=c;
     }
     else x[i]=w[b];
 }
 scanf("%d",&b);
 for(i=;i<=b;i++)
 {
     scanf("%d%d",&d,&e);
     f=;
     for(m=;m<=c;m++)
     {
         w[m]=;
     }
     for(m=d;m<=e;m++)
     {
         if(w[x[m]]==)
         {
             w[x[m]]=;
             f++;
         }
     }
     printf("%d\n",f);
 }
 }

那好，我们来讲一下正解(不会告诉你其实我问了两位大佬，学了两种方法)，但实际上，这题做法很多。

1、莫队算法(从ka哥处知道的神奇算法，据说是莫涛神犇在比赛时想出来的，很NB)。莫队算法就是解决区间查询问题的离线算法利器。（其实很简单，但是貌似涉及到更改就有些麻烦～～）很容易能想到mn的算法，而莫队就是用奇技淫巧将时间复杂度变为了O(M√n),这里我不过多赘述，不懂莫队的去这里。

下面贴一下莫队的代码（其实就是个暴力，注意每一次要先让R指针右移，再移动L指针，不然可能会出现L>R的情况，然后WA）

 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 using namespace std;
 const int maxn=,maxq=;
 int h[maxn],n,q,a[maxn],ans[maxq];
 struct data{
     int l,r,id;
     bool operator<(const data&b)const{
         if (h[l]==h[b.l]) return r<b.r;
         return l<b.l;
     }
 }que[maxq];
 inline int red(){
     int tot=,f=;char ch=getchar();
     while (ch<''||''<ch) {if (ch=='-') f=-f;ch=getchar();}
     while (''<=ch&&ch<='') tot=tot*+ch-,ch=getchar();
     return tot*f;
 }
 void blocker(){
     int k=sqrt(n);
     for (int i=;i<=n;i++) h[i]=(i-)/k+;
 }
 int L=,R=,now=,hsh[];
 void move(int x,int d){
     if (d==){
         if (hsh[a[x]]==) now++;
         hsh[a[x]]++;
     }else{
         hsh[a[x]]--;
         if (hsh[a[x]]==) now--;
     }
 }
 int main(){
     n=red();
     for (int i=;i<=n;i++) a[i]=red();
     blocker();
     q=red();
     for (int i=;i<=q;i++) que[i].l=red(),que[i].r=red(),que[i].id=i;
     sort(que+,que++q);
     for (int i=;i<=q;i++){
         while (L<que[i].l) move(L++,-);
         while (L>que[i].l) move(--L,);
         while (R<que[i].r) move(++R,);
         while (R>que[i].r) move(R--,-);
         ans[que[i].id]=now;
     }
     for (int i=;i<=q;i++) printf("%d\n",ans[i]);
     return ;
 }

2、树状数组+前缀和（老余告诉我的思路）。 因为操作中只有询问没有更新，所以可以使用离线算法，对所有问按右区间升序排序。以该数字第一次在区间中出现的点代表所有的点。如果是第一次出现，那么该数字 在之前从未出现或上一次出现不再区间内。记录每个位置i的数字的前一个相同数字出现的位置hash[i]，没有前一个相同的hash[i]为0。然后从前到后扫描询问，每次将上一个同值点的值加1，然后求当前区间的左界的前缀和就是答案了。将当前位置下个位置的值减1，这样做可以保证任意一个数字在任意一段区间中最多出现一次。

 #include<bits/stdc++.h>
 using namespace std;
 int a[],s[],has[],last[],n,m;
 struct o{
 int x,y,num;
 }q[];
 inline int gi()
 {
     int a=;char x=getchar();bool f=;
     while((x>''||x<'')&&x!='-')x=getchar();
     if(x=='-')x=getchar(),f=;
     while(x>=''&&x<='')a=a*+x-'',x=getchar();
     return f?-a:a;
 }
 bool cmp(o a,o b)
 {return a.y<b.y;}
 inline void add(int k,int a)
 {
     while(k<=n)
     {
         s[k]+=a;
         k+=k&-k;
     }
 }
 int ans(int x)
 {
     int sum=;
     while(x)
     {
         sum+=s[x];
         x-=x&-x;
     }
     return sum;
 }
 int main()
 {
     n=gi();
     for(int i=;i<=n;i++)
     {int A=gi();has[i]=last[A]+;last[A]=i;}
     m=gi();
     for(int i=;i<=m;i++)
     {
         q[i].x=gi();q[i].y=gi();q[i].num=i;
     }
     sort(q+,q+m+,cmp);
     int now=;
     for(int i=;i<=m;i++)
     {
         while(now<=q[i].y)
         {
             now++;
             add(has[now-],);
             add(now,-);
         }
         a[q[i].num]=ans(q[i].x);
     }
     for(int i=;i<=m;i++)
     printf("%d\n",a[i]);
     return ;
 }

3、主席树（可持久化线段树）。关于主席树戳这里。造一个lst[i]表示位置i的这个数上一次出现的位置（如果没有就是0） 那么对于每次询问L~R范围里的数字种数 ，其实就是询问对于L<=i<=R,满足lst[i]<L的个数。那么就很好搞了，对lst造N棵值域线段树询问就直接找到L-1这个位置看它前面有几个 。时间复杂度O(Mlogn)

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 const int N=2e5+;
 const int M=N*;
 struct President_Tree{
     int L,R,sum;
 }T[M<<];
 int last[N],top[M],root[N];
 int n,m,T_cnt=;
 int read(){
     int x=,f=;char ch=getchar();
     while (ch<'' || ch>''){if (ch=='-')f=-;ch=getchar();}
     while (''<=ch && ch<=''){x=(x<<)+(x<<)+(ch^);ch=getchar();}
     return x*f;
 }
 void insert(int &now,int x,int l=,int r=n){
     T[T_cnt++]=T[now];now=T_cnt-;
     T[now].sum++;
     if (l==r)return;
     int mid=(l+r)>>;
     if (x<=mid)insert(T[now].L,x,l,mid);
         else insert(T[now].R,x,mid+,r);
 }
 int query(int i,int j,int qr,int l=,int r=n){
     if (r<=qr)return T[j].sum-T[i].sum;
     int mid=(l+r)>>,t=query(T[i].L,T[j].L,qr,l,mid);
     if (mid<qr)t+=query(T[i].R,T[j].R,qr,mid+,r);
     return t;
 }
 int main(){
     n=read();
     for (int i=;i<=n;i++){
         int x=read();
         last[i]=top[x];
         top[x]=i;
     }
     root[]=;
     for (int i=;i<=n;i++){
         root[i]=root[i-];
         insert(root[i],last[i]);
     }
     m=read();
     for (int i=;i<=m;i++){
         int l=read(),r=read();
         printf("%d\n",query(root[l-],root[r],l-));
     }
     return ;
 }

O(Qlogn)