BZOJ3685 普通van Emde Boas树

[Solution]
I certainly do not use vEB tree, because I don't know how to solve it at all.I certainly do not use vEB tree, because I don't know how to solve it at all. I used segtree.

[Code]

#include <cstdio>
#include <cctype>
#include <memory.h>
#include <algorithm>
 
using namespace std;
 
int nextInt() {
    int d, s = 0;
    bool flag = 0;
    do {
        d = getchar();
        if (d == '-')
            flag = 1;
    } while (!isdigit(d));
    do
        s = s * 10 + d - 48, d = getchar();
    while (isdigit(d));
    return flag ? -s : s;
}
 
struct seg {
    int l, r, v;
    seg *ls, *rs;
};
 
const int maxn = 1000009;
const int inf = 0x3f3f3f3f;
 
int n, m;
seg *sp, *rt;
 
#define update(p) (p->v=p->ls->v+p->rs->v)
#define mid(p) ((p->l+p->r)>>1)
 
seg *sgtBuild(int l, int r) {
    seg *p = sp ++;
    p-> l = l;
    p-> r = r;
    p-> v = 0;
    if (l + 1 < r) {
        p-> ls = sgtBuild(l, mid(p));
        p-> rs = sgtBuild(mid(p), r);
    }
    return p;
}
 
void setVal(seg* p, int p0, int v0) {
    if (p-> l + 1 == p-> r)
        p-> v = v0;
    else {
        if (p0 < mid(p))
            setVal(p-> ls, p0, v0);
        else
            setVal(p-> rs, p0, v0);
        update(p);
    }
}
 
bool find(seg* p, int p0) {
    if (!p-> v)
        return 0;
    else if (p-> l + 1 == p-> r)
        return p-> v;
    else if (p0 < mid(p))
        return find(p-> ls, p0);
    else
        return find(p-> rs, p0);
}
 
int minVal(seg* p) {
    if (!p-> v)
        return -1;
    else if (p-> l + 1 == p-> r)
        return p-> l;
    else if (p-> ls-> v)
        return minVal(p-> ls);
    else
        return minVal(p-> rs);
}
 
int maxVal(seg* p) {
    if (!p-> v)
        return -1;
    else if (p-> l + 1 == p-> r)
        return p-> l;
    else if (p-> rs-> v)
        return maxVal(p-> rs);
    else
        return maxVal(p-> ls);
}
 
int prv(seg *p, int v0) {
    if (!p-> v)
        return -1;
    else if (p-> l + 1 == p-> r)
        return p-> l;
    else if (v0 < mid(p))
        return prv(p-> ls, v0);
    else {
        int r0 = prv(p-> rs, v0);
        if (r0 == -1)
            return maxVal(p-> ls);
        else
            return r0;
    }
}
 
int suc(seg* p, int v0) {
    if (!p-> v)
        return -1;
    else if (p-> l + 1 == p-> r)
        return p-> l;
    else if (v0 >= mid(p))
        return suc(p-> rs, v0);
    else {
        int r0 = suc(p-> ls, v0);
        if (r0 == -1)
            return minVal(p-> rs);
        else
            return r0;
    }
}
 
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
 
    sp = new seg[maxn * 3];
    n = nextInt();
    m = nextInt();
    rt = sgtBuild(-1, n + 2);
    while (m --) {
        int opt = nextInt(), x;
        if (opt == 1) {
            x = nextInt();
            setVal(rt, x, 1);
        }
        else if (opt == 2) {
            x = nextInt();
            setVal(rt, x, 0);
        }
        else if (opt == 3)
            printf("%d\n", minVal(rt));
        else if (opt == 4)
            printf("%d\n", maxVal(rt));
        else if (opt == 5) {
            int x = nextInt();
            int g = prv(rt, x - 1);
            printf("%d\n", (g == -inf) ? -1 : g);
        }
        else if (opt == 6) {
            int x = nextInt();
            int g = suc(rt, x + 1);
            printf("%d\n", (g == inf) ? -1 : g);
        }
        else {
            int x = nextInt();
            printf("%d\n", find(rt, x) ? 1 : -1);
        }
    }