Portal

這題的確很神奇.

考慮每棵樹是不會互相影響的, 所以我們可以將詢問離線來做.

因為每次生長出來的節點編號都是一樣且獨一無二的,那麼這些節點一定可以重複利用. 我們就只用建立一棵樹來維護, 然後通過不斷變化形態來解決問題.

因為我們詢問的是路徑長度, 所以詢問點的祖先長了許多不存在的節點也無所謂.

因為在沒有1操作的時間內, 所有的節點都是長到一起的. 那麼我們每次轉嫁節點比較麻煩, 所以我們考慮建立一個不存在的點來維護.

那麼如果有一個1操作, 我們就新建一個虛點, 把期間所有的點轉嫁到虛點上. 那麼虛點影響的節點是\([l, r]\), 我們只要將該點在處理第l棵樹的給過去，在r + 1

（虛點之間是維護節點順序的，所以在沒有轉嫁的時候就接到上一個虛點上面就可以了）

這樣的話我們就直接把虛點的權值賦為0，實點賦為1即可。

關鍵是我們這裡不能直接makeRoot， 或是說很麻煩。 因為我們這裡有虛點，實點， 錯綜複雜的父子關係， 直接搞的話會打亂父子關係。

那麼我們就用經典思路：
\[ Distance(u, v) = depth(u) + depth(v) - 2 * depth(LCA(u, v)) \]
這樣只要求出LCA就可以了, 那麼我們直接返回Access操作的最後一個實鏈上的節點就可以了(先Access(u), 再返回Access(v)).

然後這一題目就完美的解決了.

總結一下:

1. 如果我們要同時把大量的點一起接到別的點, 那麼我們可以建立一條虛鏈(為了維護先後順序, 如果沒有這一點那就建散點也可以) 維護即可.(套路1)

2. 我們在LCT上求LCA, 這在不MakeRoot的情況下直接返回Access的最後一個節點就可以了. 如果在含有MakeRoot的情況下可以採用標記Splay的方法.

3. 在查詢LCT一條路徑上的資訊時, 子樹上接了別的東西是無所謂的.

Code

#include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a), i##_end_ = (b); i <= i##_end_; ++i)
#define drep(i, a, b) for(int i = (a), i##_end_ = (b); i >= i##_end_; --i)
#define clar(a, b) memset((a), (b), sizeof(a))
#define debug(...) fprintf(stderr, __VA_ARGS__)
typedef long long LL;
typedef long double LD;
int read() {
    char ch = getchar();
    int x = 0, flag = 1;
    for (;!isdigit(ch); ch = getchar()) if (ch == '-') flag *= -1;
    for (;isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    return x * flag;
}
void write(int x) {
    if (x < 0) putchar('-'), x = -x;
    if (x >= 10) write(x / 10);
    putchar(x % 10 + 48);
}

const int Maxn = 1e5 + 9, Maxm = 2e5 + 9;

template <int N> struct LCT {
    struct node {
        int val, sumVal, fa, ch[2];     
    }t[N];
    int amount;

#define fa(x) t[(x)].fa
#define lc(x) t[(x)].ch[0]
#define rc(x) t[(x)].ch[1]
    
    bool isroot(int u) {
        return lc(fa(u)) != u && rc(fa(u)) != u;
    }
    void pushup(int u) {
        t[u].sumVal = t[u].val + t[lc(u)].sumVal + t[rc(u)].sumVal;
    }

    void rotate(int u) {
        int y = t[u].fa, z = t[y].fa, dir = t[y].ch[1] == u;
        if(!isroot(y)) t[z].ch[t[z].ch[1] == y] = u; t[u].fa = z;
        t[y].ch[dir] = t[u].ch[dir ^ 1]; t[t[u].ch[dir ^ 1]].fa = y;
        t[u].ch[dir ^ 1] = y; t[y].fa = u;
        pushup(y); pushup(u);
    }
    void splay(int u) {
        while (!isroot(u)) {
            int y = fa(u), z = fa(y);
            if (!isroot(y)) 
                (rc(y) == u) ^ (rc(z) == y) ? rotate(u) : rotate(y);
            rotate(u);
        }
        pushup(u);
    }

    int access(int u) {
        int y = 0;
        for (; u; u = fa(y = u)) splay(u), t[u].ch[1] = y, pushup(u);
        return y;
    }
    void cut(int u) { access(u); splay(u); t[lc(u)].fa = 0; t[u].ch[0] = 0; pushup(u); }
    void link(int u, int v) { splay(u);  t[u].fa = v; }
    int newnode(int val, int pa = 0) { t[++amount].fa = pa; t[amount].val = val; t[amount].sumVal = val; return amount; }
#undef fa
#undef lc
#undef rc
};
LCT <Maxm + Maxn> T;

struct Quer {
    int opt, Id, tar1, tar2; 
    //cut down Tar1 & link into Tar2. Id means in order, negitive: Cut/Link, positive: Query; opt: Which tree
};
bool cmp(Quer a, Quer b) { return a.opt < b.opt || (a.opt == b.opt && a.Id < b.Id); }

Quer s[Maxm * 3];

int n, m, lastVirtual, L[Maxm + Maxn], R[Maxm + Maxn], Tru[Maxm + Maxn], cntTru, tot;

bool isQuery[Maxn + Maxm];
int ans[Maxn + Maxm];

int query(int u) {
    T.splay(u); return T.t[u].sumVal;
}
void init() {
    n = read(), m = read();
    T.newnode(1), lastVirtual = T.newnode(0, 1);
    L[1] = 1; R[1] = n; Tru[1] = 1;
    /**/cntTru = 1;
}

void solve() {
    rep (i, 1, m) {
        int opt = read();
        if (opt == 0) {
            int l = read(), r = read();
            Tru[++cntTru] = T.newnode(1); L[cntTru] = l; R[cntTru] = r;
            s[++tot] = (Quer){1, i - m, T.amount, lastVirtual};
        }
        if (opt == 1) {
            int l = read(), r = read(), x = read();
            l = max(l, L[x]), r = min(r, R[x]);
            if (l > r) continue;
            int u = T.newnode(0); T.link(u, lastVirtual);
            s[++tot] = (Quer){l, i - m, u, Tru[x]};
            s[++tot] = (Quer){r + 1, i - m, u, lastVirtual};
            lastVirtual = u;
        }
        if (opt == 2) {
            int x = read(), u = read(), v = read(); isQuery[i] = 1;
            s[++tot] = (Quer){x, i, Tru[u], Tru[v]};
        }
    }


    sort(s + 1, s + tot + 1, cmp);

    int j = 1;
    rep (i, 1, n) 
        for (; s[j].opt == i; ++j) 
            if (s[j].Id > 0) {
                int target = s[j].Id;
                T.access(s[j].tar1); ans[target] += query(s[j].tar1);
                int LCA = T.access(s[j].tar2); ans[target] += query(s[j].tar2);
                T.access(LCA); ans[target] -= 2 * query(LCA);
            } else T.cut(s[j].tar1), T.link(s[j].tar1, s[j].tar2);

    rep (i, 1, m) 
        if (isQuery[i]) printf("%d\n", ans[i]);
}

int main() {
    freopen("LOJ2092.in", "r", stdin);
    freopen("LOJ2092.out", "w", stdout);

    init();
    solve();

#ifdef Qrsikno
    debug("\nRunning time: %.3lf(s)\n", clock() * 1.0 / CLOCKS_PER_SEC);
#endif
    return 0;
}