[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

说明

数据范围：

对于100%的数据，N <= 50000，M <= 200000。

解法1：树状数组。

此题首先应考虑到这样一个结论：

对于若干个询问的区间[l,r]，如果他们的r都相等的话，那么项链中出现的同一个数字，一定是只关心出现在最右边的那一个的，例如：

项链是：1 3 4 5 1

那么，对于r=5的所有的询问来说，第一个位置上的1完全没有意义，因为r已经在第五个1的右边，对于任何查询的[L,5]区间来说，如果第一个1被算了，那么他完全可以用第五个1来替代。

因此，我们可以对所有查询的区间按照r来排序，然后再来维护一个树状数组，这个树状数组是用来干什么的呢？看下面的例子：

1 2 1 3

对于第一个1，insert(1,1)；表示第一个位置出现了一个不一样的数字，此时树状数组所表示的每个位置上的数字（不是它本身的值而是它对应的每个位置上的数字）是：1 0 0 0

对于第二个2，insert(2,1)；此时树状数组表示的每个数字是1 1 0 0

对于第三个1，因为之前出现过1了，因此首先把那个1所在的位置删掉insert(1,-1),然后在把它加进来insert(3,1)。此时每个数字是0 1 1 0

如果此时有一个询问[2,3]，那么直接求sum(3)-sum(2-1)=2就是答案。

题解清楚么？

在这里也可以按左端点排序，对于一个询问（l,r),把l之前的next[i]添加进去。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAXN=50005,MAXM=200005;
struct A{
    int l,r,id; 
}q[MAXM];
int n,m,a[MAXN],b[MAXN],vis[MAXN],nxt[MAXN],ans[MAXM];
bool cmp(A a,A b)
{
    if(a.l==b.l) return a.r<b.r;
    return a.l<b.l;
}
int Lowbit(int x)
{
    return x&(-x);
}
void add(int x)
{
    while(x<=n){
        a[x]++;
        x+=Lowbit(x);
    }
}
int query(int x)
{
    int res=0;
    while(x>0){
        res+=a[x];
        x-=Lowbit(x);
    }
    return res;
}
int main()
{
    int i,j=1;
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        scanf("%d",&b[i]);
        if(!vis[b[i]]){
            add(i);
            vis[b[i]]=1;
        }
    }
    memset(vis,0,sizeof(vis));
    for(i=n;i;i--){
        if(!vis[b[i]]){
            nxt[i]=n+1;
        }
        else nxt[i]=vis[b[i]];
        vis[b[i]]=i;
    }
    scanf("%d",&m);
    for(i=1;i<=m;i++){
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].id=i;
    }
    sort(q+1,q+1+m,cmp);
    for(i=1;i<=m;i++){
        for(;j<q[i].l;j++){
            add(nxt[j]);
        }
        ans[q[i].id]=query(q[i].r)-query(q[i].l-1);
    }
    for(i=1;i<=m;i++){
        printf("%d\n",ans[i]);
    }
    return 0;
}

解法2：线段树。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAXN=50005,MAXM=200005;
struct Seg{
    int l,r,sum;
}a[MAXN];
struct A{
    int l,r,id;
}q[MAXM];
int n,m,b[MAXN],x[MAXN],vis[MAXN],nxt[MAXN],sum,ans[MAXM];
bool cmp(A a,A b)
{
    if(a.l==b.l) return a.r<b.r;
    return a.l<b.l;
}
void pushup(int x)
{
    a[x].sum=a[x<<1].sum+a[x<<1|1].sum;
}
void build(int x,int l,int r)
{
    a[x].l=l;
    a[x].r=r;
    if(l==r){
        a[x].sum=b[l];
        return;
    }
    int mid=(l+r)>>1;
    build(x<<1,l,mid);
    build(x<<1|1,mid+1,r);
    pushup(x);
}
void change(int x,int k)
{
    if(a[x].l==k&&a[x].r==k){
        b[k]=1;
        a[x].sum=1;
        return;
    }
    int mid=(a[x].l+a[x].r)>>1;
    if(mid>=k) change(x<<1,k);
    else       change(x<<1|1,k);
    pushup(x);
}
void query(int x,int sj,int tj)
{
    if(a[x].l>=sj&&a[x].r<=tj){
        sum+=a[x].sum;
        return;
    }
    int mid=(a[x].l+a[x].r)>>1;
    if(mid>=sj){
        query(x<<1,sj,tj);
    }
    if(mid+1<=tj) query(x<<1|1,sj,tj);
}
int main()
{
    int i,j=1;
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        scanf("%d",&x[i]);
        if(!vis[x[i]]){
            vis[x[i]]=1;
            b[i]=1;
        }
    }
    build(1,1,n);
    memset(vis,0,sizeof(vis));
    for(i=n;i;i--){
        if(vis[x[i]]) nxt[i]=vis[x[i]];
        vis[x[i]]=i;
    }
    scanf("%d",&m);
    for(i=1;i<=m;i++){
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].id=i;
    }
    sort(q+1,q+1+m,cmp);
//    for(i=1;i<=11;i++) cout<<a[i].sum<<"jian ";
    for(i=1;i<=m;i++){
        for(;j<q[i].l;j++){
            if(nxt[j]){
                change(1,nxt[j]);
            }
        }
        sum=0;
//        cout<<q[i].l<<' '<<q[i].r<<endl;
        query(1,q[i].l,q[i].r);
        ans[q[i].id]=sum;
    }
    for(i=1;i<=m;i++){
        printf("%d\n",ans[i]);
    }
    return 0;
}

解法3：莫队算法。

甚至不需要用树形结构，只要离线分块+暴力。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cctype>
using namespace std;
const int MAXN=50005,MAXM=200005;
struct A{
    int l,r,id;
}q[MAXM];
int n,m,a[MAXN],num[MAXN],ans[MAXM],tim,answer=0;
bool cmp(A a,A b)
{
    return a.l/tim==b.l/tim?a.r<b.r:a.l<b.l;
}
inline int read()
{
    char ch=getchar();
    int x=0;
    while(!isdigit(ch)) ch=getchar();
    while(isdigit(ch)){
        x=x*10+ch-'0';
        ch=getchar();
    }
    return x;
}
void add(int pos)
{
    if(++num[a[pos]]==1) answer++;
}
void remove(int pos)
{
    if(!--num[a[pos]])  answer--;
}
int main()
{
    int i,curl=1,curr=0;
    n=read();
    for(i=1;i<=n;i++){
        a[i]=read();
    }
    m=read();
    tim=sqrt(m);
    for(i=1;i<=m;i++){
        q[i].l=read();
        q[i].r=read();
        q[i].id=i;
    }
    sort(q+1,q+1+m,cmp);
    for(i=1;i<=m;i++){
        while(curl<q[i].l){
            remove(curl++);
        }
        while(curl>q[i].l){
            add(--curl);
        }
        while(curr<q[i].r){
            add(++curr);
        }
        while(curr>q[i].r){
            remove(curr--);
        }
        ans[q[i].id]=answer;
    }
    for(i=1;i<=m;i++){
        printf("%d\n",ans[i]);
    }
    return 0;
}