bzoj4825

LCT

昨天调试一天没出来，今天推倒重写还是gg了，内心崩溃照着源代码抄，结果发现自己把原树fa和splay的fa一起维护，各种re。。。

其实我们手玩一下，发现其实树的形态变化很小，那么就可以用lct维护了，查询就是相当于查询点到root的点权和，点权为1

删除什么的手画一下就行了

然后我们要用一个数组维护一下原树形态，因为splay是二叉树，可以很方便地维护树的形态，但是一般的树比较麻烦，因为删除儿子什么的的确很烦。这些信息不能再lct上维护，因为lct上fa会变化，里面的fa是splay的fa，不是原树的fa，就破坏了原树形态，所以不能这样维护

然后就是lct各种操作。。。几个月没写都忘了。。。

#include<bits/stdc++.h>
using namespace std;
const int N = , inf = ;
namespace IO
{
    const int Maxlen = N * ;
    char buf[Maxlen], *C = buf;
    int Len;
    inline void read_in()
    {
        Len = fread(C, , Maxlen, stdin);
        buf[Len] = '\0';
    }
    inline void fread(int &x)
    {
        x = ;
        int f = ;
        while (*C < '' || '' < *C) { if(*C == '-') f = -; ++C; }
        while ('' <= *C && *C <= '') x = (x << ) + (x << ) + *C - '', ++C;
        x *= f;
    }
    inline void read(int &x)
    {
        x = ;
        int f = ; char c = getchar();
        while(c < '' || c > '') { if(c == '-') f = -; c = getchar(); }
        while(c >= '' && c <= '') { x = (x << ) + (x << ) + c - ''; c = getchar(); }
        x *= f;
    }
    inline void read(long long &x)
    {
        x = ;
        long long f = ; char c = getchar();
        while(c < '' || c > '') { if(c == '-') f = -; c = getchar(); }
        while(c >= '' && c <= '') { x = (x << 1ll) + (x << 3ll) + c - ''; c = getchar(); }
        x *= f;
    }
} using namespace IO;
int m, opt, cnt, key, root;
set<pair<int, int> > s;
namespace LCT
{
    int st[N];
    struct node {
        int size, l, r, c[], fa, tag;
    } t[N];
    inline bool wh(int x) { return t[t[x].fa].c[] == x; }
    inline void update(int x) { t[x].size = t[t[x].c[]].size + t[t[x].c[]].size + ; }
    inline bool isroot(int x) { return t[t[x].fa].c[] != x && t[t[x].fa].c[] != x; }
    inline void pushdown(int x)
    {
        if(!t[x].tag) return;
        swap(t[x].c[], t[x].c[]);
        t[t[x].c[]].tag ^= ;
        t[t[x].c[]].tag ^= ;
        t[x].tag ^= ;
    }
    inline void up(int x)
    {
        int top = ;
        st[++top] = x;
        while(!isroot(x))
        {
            x = t[x].fa;
            st[++top] = x;
        }
        for(int i = top; i; --i) pushdown(st[i]);
    }
    inline void rotate(int x)
    {
        int y = t[x].fa, z = t[y].fa, w = wh(x);
        t[x].fa = z;
        if(!isroot(y)) t[z].c[wh(y)] = x;
        t[y].c[w] = t[x].c[w ^ ];
        t[t[x].c[w ^ ]].fa = y;
        t[x].c[w ^ ] = y;
        t[y].fa = x;
        update(y);
        update(x);
    }
    inline void splay(int x)
    {
        up(x);
        while(!isroot(x))
        {
            if(!isroot(t[x].fa)) rotate(wh(x) == wh(t[x].fa) ? t[x].fa : x);
            rotate(x);
        }
    }
    inline void access(int u)
    {
        for(int f = ; u; f = u, u = t[u].fa)
        {
            splay(u);
            t[u].c[] = f;
            update(u);
        }
    }
    inline void rever(int u)
    {
        access(u);
        splay(u);
        t[u].tag ^= ;
    }
    inline void link(int u, int v)
    {
        if(!u || !v) return;
        rever(u);
        t[u].fa = v;
    }
    inline void cut(int u, int v)
    {
        if(!u || !v) return;
        rever(u);
        access(v);
        splay(v);
        t[v].c[] = t[u].fa = ;
        update(v);
    }
    inline void que(int u)
    {
        rever(root);
        access(u);
        splay(u);
        printf("%d\n", t[u].size);
    }
} using LCT :: link; using LCT :: cut; using LCT :: que;
struct info {
    int l, r, fa;
} t[N];
inline void insert(int key)
{
    pair<int, int> o = make_pair(key, ++cnt);
    set<pair<int, int> > :: iterator it1, it2;
    it1 = it2 = s.insert(o).first;
    int u = , v = , x = cnt;
    if(it1 != s.begin()) u = (--it1) -> second;
    if(++it2 != s.end()) v = it2 -> second;
    if(u ==  && v == ) root = x;
    else if(v && t[v].l == )
    {
        t[v].l = x;
        t[x].fa = v;
        link(v, cnt);
    }
    else if(u && t[u].r == )
    {
        t[u].r = x;
        t[x].fa = u;
        link(u, cnt);
    }
    que(cnt);
}
inline void splay_min()
{
    int u = s.begin() -> second, r = t[u].r, p = t[u].fa;
    que(u);
    if(u == root) return;
    cut(u, p);
    cut(u, r);
    link(p, r);
    link(u, root);
    t[u].r = root;
    t[root].fa = u;
    t[r].fa = p;
    t[p].l = r;
    root = u;
}
inline void splay_max()
{
    set<pair<int, int> > :: iterator it = s.end();
    int u = (--it) -> second, l = t[u].l, p = t[u].fa;
    que(u);
    if(u == root) return;
    cut(u, p);
    cut(u, l);
    link(p, l);
    link(u, root);
    t[u].l = root;
    t[root].fa = u;
    t[l].fa = p;
    t[p].r = l;
    root = u;
}
inline void del_min()
{
    set<pair<int, int> > :: iterator it = s.begin();
    int u = it -> second, r = t[u].r, p = t[u].fa;
    que(u);
    if(u == root)
    {
        cut(u, r);
        t[r].fa = ;
        root = r;
    }
    else
    {
        cut(u, p);
        cut(u, r);
        link(p, r);
        t[r].fa = p;
        t[p].l = r;
    }
    s.erase(it);
}
inline void del_max()
{
    set<pair<int, int > > :: iterator it = s.end();
    int u = (--it) -> second, l = t[u].l, p = t[u].fa;
    que(u);
    if(u == root)
    {
        cut(u, l);
        t[l].fa = ;
        root = l;
    }
    else
    {
        cut(u, p);
        cut(u, l);
        link(p, l);
        t[l].fa = p;
        t[p].r = l;
    }
    s.erase(it);
}
int main()
{
//    read_in();
    read(m);
    while(m--)
    {
        read(opt);
        if(opt == ) read(key), insert(key);
        if(opt == ) splay_min();
        if(opt == ) splay_max();
        if(opt == ) del_min();
        if(opt == ) del_max();
    }
    return ;
}