莫队或权值线段树 或主席树 p4137

题目描述

有一个长度为n的数组{a1,a2,…,an}。m次询问，每次询问一个区间内最小没有出现过的自然数。

输入格式

第一行n,m。

第二行为n个数。

从第三行开始，每行一个询问l,r。

输出格式

一行一个数，表示每个询问的答案。

一开始以为像答案这样的做法会超时，没想到真是这样写。。。

#include<cstdio>
#include<algorithm>
#include<math.h>
#include<string.h>
using namespace std;
const int maxn=2e5+10;
int num[maxn];
int answer,block;
int vis[maxn];
struct node
{
    int l,r,id;
    int Ans;
}ans[maxn];
bool cmp(node x,node y)
{
    if(x.l/block!=y.l/block)
        return x.l<y.l;
    if(x.l/block&1)        //使用波形排序，可进一步的优化
        return x.r<y.r;
    return x.r>y.r;
}
bool CMP(node x,node y)
{
    return x.id<y.id;
}
void Delete(int pos)
{
    vis[num[pos]]--;
    if(!vis[num[pos]]&&num[pos]<answer){
        answer=num[pos];
    }
}
void add(int pos)
{
    vis[num[pos]]++;
    if(vis[num[pos]]==1&&answer==num[pos]){
        int tmp=answer+1;
        while(1){
            if(!vis[tmp]){
                answer=tmp;
                return;
            }
            tmp++;
        }
    }
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    block=sqrt(n);
    for(int i=1;i<=n;i++) scanf("%d",&num[i]);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&ans[i].l,&ans[i].r);
        ans[i].id=i;
    }
    sort(ans+1,ans+1+m,cmp);
    int left=1,right=0;
    for(int i=1;i<=m;i++){
        while(ans[i].l>left) Delete(left++);
        while(ans[i].l<left) add(--left);
        while(ans[i].r>right) add(++right);
        while(ans[i].r<right) Delete(right--);
        ans[i].Ans=answer;
    }
    sort(ans+1,ans+1+m,CMP);
    for(int i=1;i<=m;i++)
        printf("%d\n",ans[i].Ans);
    return 0;
}

 

还有一个权值线段树的解法：

对于第i棵权值线段树，维护一下数列前ii项中每个权值出现的最靠右的位置。然后向上更新一下最小值。这样如果某个权值最靠右的位置都比查询区间左端点小的话，那它一定没有在这个区间里出现。维护最小值目的就是看最小的是否比左端点大，根据这个在线段树上二分。

权值范围是10^9109的。题解里有说答案最大为nn，直接把>n>n的a[i]a[i]处理为n+1n+1就行。蒟蒻没有想到QAQQAQ，说一下蒟蒻的处理：

用离散化，但是一个权值没有在数列里出现过的话就不会在离散化数组中，也不会出现在线段树中，查询会出锅。注意到一个询问的答案要么是00，要么是数列中某个数的值+1+1。这样离散化时把00和每个出现过的权值+1+1都丢进去就行了QwQQwQ。

当然这道题不强制在线也不修改，可以把询问离线下来一边扫一边加，遇到询问右端点就查询左端点，不需要主席树（可持久化线段树），一棵权值线段树就可以了。

时间复杂度：O(nlogn)

#include<cstdio>
#include<algorithm>
#include<math.h>
#include<string.h>
#include<vector>
using namespace std;
const int maxn=2e5+10;
int ans[maxn];
int t;   //T为离散化之后的数组长度
int a[maxn],b[maxn*2],cnt;  //原数组和离散化的数组，以及下标cnt；
int tree[maxn<<5];
int root[maxn];
void update(int root)
{
    tree[root]=min(tree[root<<1],tree[root<<1|1]);
}
void add(int num,int l,int r,int root,int base)
{
    if(l==r){
        tree[root]=base;
        return;
    }
    int mid=l+r>>1;
    if(num<=mid) add(num,l,mid,root<<1,base);
    else     add(num,mid+1,r,root<<1|1,base);
    update(root);
}
int query(int pos)
{
    int l=1,r=t;
    int root=1;
    while(l<r){
        int mid=l+r>>1;
        //如果左区间的值至少存在一个权值的下标小于pos的，就证明此范围内有符合条件的数；
        //就像左边二分；
        if(tree[root<<1]<pos) r=mid,root=root<<1;
        //否则向右边二分；
        else l=mid+1,root=root<<1|1;
    }
    return b[l];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    b[++cnt]=0;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        b[++cnt]=a[i];
        b[++cnt]=a[i]+1;
    }
    sort(b+1,b+1+cnt);
    t=unique(b+1,b+1+cnt)-b-1;
    for(int i=1;i<=n;i++){
        a[i]=lower_bound(b+1,b+1+t,a[i])-b;
        add(a[i],1,t,1,i,root[i],root[i-1]);
    }
    return 0;
}

 因为权值线段树能解这道题，所以用主席树解就显得没有必要了，但我还是练了练手。

#include<cstdio>
#include<algorithm>
#include<math.h>
#include<string.h>
using namespace std;
const int maxn=4e5+10;
int a[maxn],b[maxn],cnt=0,len;
struct node{int l,r,id;}tree[maxn<<5];int cot;
//主席树需要开的空间比一般线段树更大，另外后面的cot是记录主席树节点用的。
int Root[maxn];
void build(int &x,int l,int r)
{
    //这里的&x会把x得到的值传给这个变量，也就是Root[0];
    //建一波空树，其实可以不建的，之前打过不建的代码，
    //但总觉得不建的话心里不踏实。啊哈哈哈
    x=++cot;
    if(l==r) return ;
    int mid=l+r>>1;
    build(tree[x].l,l,mid);
    build(tree[x].r,mid+1,r);
}
void add(int num,int l,int r,int &x,int y,int pos)
{
    //同上，这里的&x会传给root[i];
    tree[++cot]=tree[y];
    x=cot; //将cot传给x,这个cot储存的是Root[i]这个节点的值，这个节点是根节点。
    if(l==r){
        tree[cot].id=pos; 
        //tree[x].id=pos;  这里也可以这样写
        return;
    }
    int mid=l+r>>1;
    if(num<=mid) add(num,l,mid,tree[x].l,tree[y].l,pos);
    else add(num,mid+1,r,tree[x].r,tree[y].r,pos);
    int left=tree[x].l,right=tree[x].r;
    tree[x].id=min(tree[left].id,tree[right].id);  //传递最小值；
}
int query(int pos,int base)
{
    //这一部分是本题内容。
    int l=1,r=len;
    while(l<r){
        int mid=l+r>>1;
        //left存储的是根节点的左区间，right为右区间。
        int left=tree[base].l,right=tree[base].r;
        if(tree[left].id<pos) r=mid,base=left;
        else l=mid+1,base=right;
    }
    return b[l];
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    b[++cnt]=0;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        b[++cnt]=a[i];
        b[++cnt]=a[i]+1;
    }
    sort(b+1,b+1+cnt);
    len=unique(b+1,b+1+cnt)-b-1;
    build(Root[0],1,len);
    for(int i=1;i<=n;i++){
        a[i]=lower_bound(b+1,b+1+len,a[i])-b;
        add(a[i],1,len,Root[i],Root[i-1],i);
    }
    for(int i=1;i<=m;i++){
        int l,r;
        scanf("%d%d",&l,&r);
        int ans=query(l,Root[r]);
        printf("%d\n",ans);
    }
    return 0;
}