hdu4747-线段树

现在有一个长度为n的序列(n<=200000) 求出每一个mex(l,r) 1<=l<=r<=n
mex(l,r)=l到r区间没有出现过的最小非负整数。
考虑如果固定左端点，那么右端点从1到n的话他们的mex是非递减的那么可以
把n个区间选择对答案的贡献加到答案里面，如果把这长度分别为1,2。。n的
区间去掉最左端的数情况会怎么样呢？比如左端点是下标是i，值是x，右端点是
j,那么现在我们就是要把(i,j)变成(i+1,j)，如果mex(i,j)<=x那么左端点i的去掉
并不会对整体造成影响但是如果mex(i,j)>x的时候，那么找到最小的k使得mex(i,k)>x
那么左端点为i+1，右端点为从这个k到下一个x（或者没有x，那就到j吧），他们的mex
都变成了x，所以考虑把线段树这个区间的值修改成x，线段树的区间l，r即是我们当前
左端点，右端点为l到r时候的信息，当然我们保存一个sum（对答案的贡献）和一个mx
（这个l到r中最大的mex值，以便二分找到第一个大于x的下标）。每次删除左端点答案
加上一个tree[1].sum就可以了

#include <iostream>
#include <cstdio>
#include <map>
using namespace std;
typedef long long ll;
const int maxn=2e5+100;
struct SegmentTree
{
    int l,r,mx;                      //mx为区间l到r最大的左端点固定的mex
    ll sum;
    bool lazy;    //是否向下传递
};
SegmentTree tree[maxn*4];
map<int,int> mp;
int p[maxn],Nex[maxn],mex[maxn];
void Build(int root,int l,int r);
void PushDown(int root);
void Update(int root,int l,int r,int ul,int ur,int val);
int Get(int root,int val);
int main()
{
    int n,now;
    ll ans;
    while(scanf("%d",&n)!=EOF)
    {
        if(!n)
            break;
        mp.clear();
        ans=0;
        now=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&p[i]);
            mp[p[i]]=1;
            while(mp[now]) now++;
            mex[i]=now;
        }
        mp.clear();
        for(int i=n;i>=1;i--)
        {
            if(mp[p[i]]) Nex[i]=mp[p[i]];
            else Nex[i]=n+1;
            mp[p[i]]=i;
        }
        Build(1,1,n);
        for(int i=1;i<=n;i++)
        {
            ans+=tree[1].sum;
            if(tree[1].mx>p[i])
            {
                int l=Get(1,p[i]);
            int r=Nex[i];
            if(l<=r-1)
                Update(1,1,n,l,r-1,p[i]);
            }
            Update(1,1,n,i,i,0);
        }
        printf("%lld\n",ans);
    }
    return 0;
}
void Build(int root,int l,int r)
{
    tree[root].l=l,tree[root].r=r;
    if(l==r)
    {
        tree[root].sum=tree[root].mx=mex[l];
        tree[root].lazy=false;
        return;
    }
    int mid=(l+r)/2;
    Build(root*2,l,mid);
    Build(root*2+1,mid+1,r);
    tree[root].sum=tree[root*2].sum+tree[root*2+1].sum;
    tree[root].mx=max(tree[root*2].mx,tree[root*2+1].mx);
    tree[root].lazy=false;
}
void PushDown(int root)
{
    if(tree[root].lazy)
    {
        tree[root*2].sum=(tree[root*2].r-tree[root*2].l+1)*tree[root].mx;
        tree[root*2+1].sum=(tree[root*2+1].r-tree[root*2+1].l+1)*tree[root].mx;
        tree[root*2].mx=tree[root*2+1].mx=tree[root].mx;
        tree[root*2].lazy=tree[root*2+1].lazy=true;
        tree[root].lazy=false;
    }
}
void Update(int root,int l,int r,int ul,int ur,int val)
{
    if(ul>r||ur<l)
        return;
    if(ul<=l&&ur>=r)
    {
        tree[root].sum=(tree[root].r-tree[root].l+1)*val;
        tree[root].mx=val;
        tree[root].lazy=true;
        return;
    }
    PushDown(root);
    int mid=(l+r)/2;
    Update(root*2,l,mid,ul,ur,val);
    Update(root*2+1,mid+1,r,ul,ur,val);
    tree[root].sum=tree[root*2].sum+tree[root*2+1].sum;
    tree[root].mx=max(tree[root*2].mx,tree[root*2+1].mx);
}
int Get(int root,int val)
{
    if(tree[root].l==tree[root].r)
        return tree[root].l;
    PushDown(root);
    if(tree[root*2].mx<val)
        return Get(root*2+1,val);
    else
        return Get(root*2,val);
}
/*
现在有一个长度为n的序列(n<=200000) 求出每一个mex(l,r) 1<=l<=r<=n
mex(l,r)=l到r区间没有出现过的最小非负整数。
考虑如果固定左端点，那么右端点从1到n的话他们的mex是非递减的那么可以
把n个区间选择对答案的贡献加到答案里面，如果把这长度分别为1,2。。n的
区间去掉最左端的数情况会怎么样呢？比如左端点是下标是i，值是x，右端点是
j,那么现在我们就是要把(i,j)变成(i+1,j)，如果mex(i,j)<=x那么左端点i的去掉
并不会对整体造成影响但是如果mex(i,j)>x的时候，那么找到最小的k使得mex(i,k)>x
那么左端点为i+1，右端点为从这个k到下一个x（或者没有x，那就到j吧），他们的mex
都变成了x，所以考虑把线段树这个区间的值修改成x，线段树的区间l，r即是我们当前
左端点，右端点为l到r时候的信息，当然我们保存一个sum（对答案的贡献）和一个mx
（这个l到r中最大的mex值，以便二分找到第一个大于x的下标）。每次删除左端点答案
加上一个tree[1].sum就可以了
*/