hdu4747——Mex

1、题目大意：对一个序列的每一个区间求Mex，最后所有的mex相加(mex就是SG的那个)，力求nlogn。。。

2、分析：最近开始刷线段树了，还是有很多不会啊

首先把1-1 1-2 1-… 1-n这些区间的mex算出来，他一定是单调递增的，那么以2为左端点的区间，

他们的mex是可以用线段树做区间修改以1为左端点的区间的，比若说我们要修改以2为左端点的，

这个序列，下一次出现a[1]这个数的地方以后都没有影响，这是一定的

然后我们对于2到a[1]这些值所代表的区间mex值，我们就是要算qo = min(q[o], a[1]);

以为q[o]是单调的，所以我们可以二分，但是以为这道题是lazy所以二分的复杂度是log^2n，（因为要单点询问）

然而这会TLE

后来看了网上的kuangbin的blog里有这个的处理方法， 再维护一个区间最小值，然后写一个神奇的函数

这是一个递归函数，如果左儿子区间的RMQ

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
#define LL long long
struct segment_tree{
    LL q[2000000];
    LL m[2000000];
    LL lazy[2000000];
    LL x, y, z;
    void add(LL l, LL r, LL o){
        if(lazy[o] != -1){
            lazy[2 * o] = lazy[o];
            lazy[2 * o + 1] = lazy[o];
            q[o] = (LL)lazy[o] * (r - l + 1);
            m[o] = lazy[o];
            lazy[o] = -1;
        }
        if(x > r || y < l) return;
        if(x <= l && r <= y){
            lazy[2 * o] = z;
            lazy[2 * o + 1] = z;
            q[o] = z * (r - l + 1);
            m[o] = z;
            return;
        }
        LL mid = (l + r) / 2;
        add(l, mid, 2 * o);
        add(mid + 1, r, 2 * o + 1);
        q[o] = q[2 * o] + q[2 * o + 1];
        m[o] = m[2 * o];
        if(m[2 * o + 1] > m[o]) m[o] = m[2 * o + 1];
        return;
    }
    LL query(LL l, LL r, LL o){
        if(lazy[o] != -1){
            lazy[2 * o] = lazy[o];
            lazy[2 * o + 1] = lazy[o];
            q[o] = (LL)lazy[o] * (r - l + 1);
            m[o] = lazy[o];
            lazy[o] = -1;
        }
        if(x > r || y < l) return 0;
        if(x <= l && r <= y) return q[o];
        LL mid = (l + r) / 2;
        LL ret = 0;
        ret += query(l, mid, 2 * o);
        ret += query(mid + 1, r, 2 * o + 1);
        q[o] = q[2 * o] + q[2 * o + 1];
        m[o] = m[2 * o];
        if(m[2 * o + 1] > m[o]) m[o] = m[2 * o + 1];
        return ret;
    }
    LL get(LL l, LL r, LL o, LL u, LL st){
        if(lazy[o] != -1){
            lazy[2 * o] = lazy[o];
            lazy[2 * o + 1] = lazy[o];
            q[o] = (LL)lazy[o] * (r - l + 1);
            m[o] = lazy[o];
            lazy[o] = -1;
        }
        if(m[o] < u) return 0;
        if(st == 1) return 0;
        if(l == r) return l;
        LL mid = (l + r) / 2;
        LL ret = 1;
        LL wl;
        if(mid < x){
            ret = 0;
            wl = get(l, mid, 2 * o, u, 1);
        }
        else ret = get(l, mid, 2 * o, u, 0);
        if(ret == 0) ret = get(mid + 1, r, 2 * o + 1, u, 0);
        else wl = get(mid + 1, r, 2 * o + 1, u, 1);
        q[o] = q[2 * o] + q[2 * o + 1];
        m[o] = m[2 * o];
        if(m[2 * o + 1] > m[o]) m[o] = m[2 * o + 1];
        return ret;
    }
} wt;
LL value[1000000];
bool vis[1000000];
LL head[1000000];
LL Next[1000000];
int main(){
    LL n;
    while(scanf("%I64d", &n) != EOF){
        if(n == 0) return 0;
        LL ans = 0;
        wt.x = 1;
        wt.y = n;
        wt.z = 0;
        wt.add(1, n, 1);
        memset(vis, 0, sizeof(vis));
        for(LL i = 0; i <= 300000; i ++) head[i] = n + 1;
        for(LL i = 1; i <= n; i ++) scanf("%I64d", &value[i]);
        LL o = 0;
        for(LL i = 1; i <= n; i ++){
            if(value[i] < n) vis[value[i]] = 1;
            while(vis[o]) o ++;
            wt.x = i; wt.y = i; wt.z = o;
            wt.add(1, n, 1);
            ans += o;
        }
        for(LL i = n; i >= 1; i --){
            if(value[i] < n){
                Next[i] = head[value[i]];
                head[value[i]] = i;
            }
        }
        for(LL i = 2; i <= n; i ++){
            LL h = value[i - 1];
            wt.x = i;
            LL l = wt.get(1, n, 1, h, 0);
            if(l <= Next[i - 1] - 1 && l != 0){
                wt.x = l; wt.y = Next[i - 1] - 1; wt.z = h;
                wt.add(1, n, 1);
            }
            wt.x = i; wt.y = n;
            ans += wt.query(1, n, 1);
        }
        printf("%I64d\n", ans);
    }
     return 0;
}