BZOJ 3585 mex - 莫队+（分块/树状数组+二分/乱搞/主席树）

首先注意到大于n的数可以忽略，因其对答案绝无影响。

1.分块大法好
就是把n分块，如果数添加之前不存在则把数填进去，块的计数++，统计时扫一遍块，找到第一个未填满的块，在其中找数.
（其实复杂度我也不太会算）

复杂度：

$$O(q\sqrt{n}+q\sqrt{n})$$
用时：13768ms

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=200005;

struct query
{
    int x,y,id,block;
    bool operator < (const query tmp)const
    {
        return block<tmp.block||(block==tmp.block&&y<tmp.y);
    } 
}q[maxn];

int n,m,bl;
int s[maxn],belong[maxn],num[maxn],cnt[maxn],res[maxn];

int getans()
{
    for(int i=1;i<=bl;i++)if(!num[i]!=bl)
        for(int j=0;j<bl;j++)if(!cnt[(i-1)*bl+j])
            return (i-1)*bl+j;
}
int main()
{
    scanf("%d%d",&n,&m);
    bl=sqrt(n+1);
    for(int i=1;i<=n;i++)
        scanf("%d",s+i);
    for(int i=1;i<=m;i++)
        scanf("%d%d",&q[i].x,&q[i].y),
        q[i].id=i,
        q[i].block=(q[i].x-1)/bl+1;
    for(int i=0;i<=n+1;i++)
        belong[i]=i/bl+1;
    sort(q+1,q+m+1);
    int l=1,r=1;
    num[belong[s[1]]]=cnt[s[1]]=1;
    for(int i=1;i<=m;i++)
    {
        while(l<q[i].x)
        {
            if(s[l]<=n)
            {
                cnt[s[l]]--;
                if(!cnt[s[l]])num[belong[s[l]]]--;
            }
            l++;
        }
        while(l>q[i].x)
        {
            l--;
            if(s[l]<=n)
            {
                if(!cnt[s[l]])num[belong[s[l]]]++;
                cnt[s[l]]++;
            }
        }
        while(r<q[i].y)
        {
            r++;
            if(s[r]<=n)
            {
                if(!cnt[s[r]])num[belong[s[r]]]++;
                cnt[s[r]]++;
            }
        }
        while(r>q[i].y)
        {
            if(s[r]<=n)
            {
                cnt[s[r]]--;
                if(!cnt[s[r]])num[belong[s[r]]]--;
            }   
            r--;
        }
        res[q[i].id]=getans();
    }
    for(int i=1;i<=m;i++)
        printf("%d\n",res[i]);
    return 0;
} 

2.二分+树状数组
这个很好想啊，如果没有就加到计数的树状数组里，查询时二分答案看前缀是否填满。

复杂度：

$$O(q\sqrt{n}logn+qlogn)$$
用时：10044ms

其实这个在极端状态下复杂度肯定没有分块优，但是由于数据中需要修改的值少，所以导致询问复杂度低的用时少一些（数据真良心）。

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>

using namespace std;

const int maxn=200005;

struct query
{
    int x,y,id,block;
    bool operator < (const query tmp)const
    {
        return block<tmp.block||(block==tmp.block&&y<tmp.y);
    } 
}q[maxn];

int n,m,bl;
int s[maxn],cnt[maxn],res[maxn],c[maxn];

int query(int x)
{
    int res=0;
    for(int i=x;i;i-=i&-i)
        res+=c[i];
    return res;
}
void add(int x,int val)
{
    for(int i=x;i<=n;i+=i&-i)
        c[i]+=val;
}
int Bi_search()
{
    int l=1,r=n+1;
    while(l<r)
    {
        int mid=l+r>>1;
        if(query(mid)==mid)l=mid+1;
        else r=mid;
    }
    return l-1;
}
int main()
{
    scanf("%d%d",&n,&m);
    bl=sqrt(n+1);
    for(int i=1;i<=n;i++)
        scanf("%d",s+i);
    for(int i=1;i<=m;i++)
        scanf("%d%d",&q[i].x,&q[i].y),
        q[i].id=i,
        q[i].block=(q[i].x-1)/bl+1;
    sort(q+1,q+m+1);
    int l=1,r=1;
    cnt[s[l]]=1;
    add(s[l]+1,1);
    for(int i=1;i<=m;i++)
    {
        while(l>q[i].x)
        {
            l--;
            if(s[l]<=n)
            {
                if(!cnt[s[l]])add(s[l]+1,1);
                cnt[s[l]]++;
            }
        }
        while(r<q[i].y)
        {
            r++;
            if(s[r]<=n)
            {
                if(!cnt[s[r]])add(s[r]+1,1);
                cnt[s[r]]++;
            }
        }
        while(l<q[i].x)
        {
            if(s[l]<=n)
            {
                cnt[s[l]]--;
                if(!cnt[s[l]])add(s[l]+1,-1);
            }
            l++;
        }
        while(r>q[i].y)
        {
            if(s[r]<=n)
            {
                cnt[s[r]]--;
                if(!cnt[s[r]])add(s[r]+1,-1);
            }   
            r--;
        }
        res[q[i].id]=Bi_search();
    }
    for(int i=1;i<=m;i++)
        printf("%d\n",res[i]);
    return 0;
} 

3.乱搞
这个能看出数据是真的良心（纯属臆测，其实感觉复杂度就是这样的吧233）。。。

理论复杂度：

$$O(qn\sqrt{n})$$
用时：11852ms

戳这里->http://blog.csdn.net/ws_yzy/article/details/50571003

4.主席树
这个复杂度应该是最低的了，而且寻找last比区间left小这个思想非常常见，应该掌握一下，类似这个思想的还有树套树（或者分块）的BZOJ 2120，还有一个比较相像的BZOJ 3747

大概就是以数列下标为根建立主席树，主席树下标为0~n的自然数，每次查找最小的满足last < left的数。

复杂度：

$$O(nlogn+qlogn)$$
用时：4652ms

戳这里->http://www.cnblogs.com/candy99/p/6354623.html