洛谷P4319 变化的道路

题意：给定图，每条边都有一段存在时间。求每段时间的最小生成树。

解：动态MST什么毒瘤...洛谷上还是蓝题...

线段树分治 + lct维护最小生成树。

对时间开线段树，每条边的存在时间在上面会对应到logn个区间。

我们先把这些边加到线段树对应节点上，但是不在lct上面加。最后扫一遍线段树。

扫到一个节点的时候把当前节点上的边加入lct，同时记录做了什么操作。回溯的时候还原操作。

最小生成树的权值不用lct维护子树和，直接用一个变量，加边删边的时候跟着修改即可。

这样复杂度就是nlog²n的...虽然常数上天了。

注意一下就是，回溯操作的时候顺序必须严格倒序。否则会出现一些情况导致re。

#include <cstdio>
#include <algorithm>
#include <vector>

typedef long long LL;
const int N = 500010, lm = 32766;

int fa[N], s[N][2], large[N], p[N], top;
bool rev[N];
LL val[N];

inline void pushup(int x) {
    large[x] = x;
    if(s[x][0] && val[large[x]] < val[large[s[x][0]]]) {
        large[x] = large[s[x][0]];
    }
    if(s[x][1] && val[large[x]] < val[large[s[x][1]]]) {
        large[x] = large[s[x][1]];
    }
    return;
}

inline void pushdown(int x) {
    if(rev[x]) {
        std::swap(s[x][0], s[x][1]);
        if(s[x][0]) {
            rev[s[x][0]] ^= 1;
        }
        if(s[x][1]) {
            rev[s[x][1]] ^= 1;
        }
        rev[x] = 0;
    }
    return;
}

inline bool no_root(int x) {
    return (s[fa[x]][0] == x) || (s[fa[x]][1] == x);
}

inline void rotate(int x) {
    int y = fa[x];
    int z = fa[y];
    bool f = (s[y][1] == x);

    fa[x] = z;
    if(no_root(y)) {
        s[z][s[z][1] == y] = x;
    }
    s[y][f] = s[x][!f];
    if(s[x][!f]) {
        fa[s[x][!f]] = y;
    }
    s[x][!f] = y;
    fa[y] = x;

    pushup(y);
    return;
}

inline void splay(int x) {
    int y = x;
    p[++top] = y;
    while(no_root(y)) {
        y = fa[y];
        p[++top] = y;
    }
    while(top) {
        pushdown(p[top]);
        top--;
    }

    y = fa[x];
    int z = fa[y];
    while(no_root(x)) {
        if(no_root(y)) {
            (s[z][1] == y) ^ (s[y][1] == x) ?
            rotate(x) : rotate(y);
        }
        rotate(x);
        y = fa[x];
        z = fa[y];
    }
    pushup(x);
    return;
}

inline void access(int x) {
    int y = 0;
    while(x) {
        splay(x);
        s[x][1] = y;
        pushup(x);
        y = x;
        //printf("fa %d = %d 
", x, fa[x]);
        x = fa[x];
    }
    return;
}

inline void make_root(int x) {
    access(x);
    splay(x);
    rev[x] = 1;
    return;
}

inline int find_root(int x) {
    access(x);
    splay(x);
    while(s[x][0]) {
        x = s[x][0];
        pushdown(x);
    }
    return x;
}

inline void link(int x, int y) {
    //printf("link %d %d 
", x, y);
    make_root(x);
    fa[x] = y;
    return;
}

inline void cut(int x, int y) {
    //printf("cut %d %d 
", x, y);
    make_root(x);
    access(y);
    splay(y);
    s[y][0] = fa[x] = 0;
    pushup(y);
    return;
}

inline int getMax(int x, int y) {
    make_root(x);
    access(y);
    splay(y);
    return large[y];
}
// lct OVER

struct Edge {
    int u, v;
    LL val;
    Edge(int x = 0, int y = 0, LL z = 0) {
        u = x;
        v = y;
        val = z;
    }
}edge[N];

struct Node {
    bool f; // 0 link 1 cut
    int x;
    Node(bool F = 0, int X = 0) {
        f = F;
        x = X;
    }
};

std::vector<int> id[N];
std::vector<Node> v[N];
int n;
LL Sum;

void add(int L, int R, int v, int l, int r, int o) {
    if(L <= l && r <= R) {
        id[o].push_back(v);
        return;
    }
    int mid = (l + r) >> 1;
    if(L <= mid) {
        add(L, R, v, l, mid, o << 1);
    }
    if(mid < R) {
        add(L, R, v, mid + 1, r, o << 1 | 1);
    }
    return;
}

void solve(int l, int r, int o) {
    //printf("solve %d %d %d 
", l, r, o);
    for(int i = 0; i < id[o].size(); i++) {
        int t = id[o][i];
        int x = edge[t].u, y = edge[t].v;
        int p = getMax(x, y);
        if(val[p] < edge[t].val) {
            continue;
        }
        cut(edge[p].u, p);
        cut(edge[p].v, p);
        link(x, t);
        link(y, t);
        v[o].push_back(Node(1, p));
        v[o].push_back(Node(0, t)); // pay attention! this must be behind
        Sum -= val[p];
        Sum += val[t];
        //printf(" > push %d %d 
", t, p);
    }
    if(l == r) {
        printf("%lld
", Sum + 1);
    }
    else {
        int mid = (l + r) >> 1;
        solve(l, mid, o << 1);
        solve(mid + 1, r, o << 1 | 1);
    }
    //printf(" -- solve %d %d %d 
", l, r, o);
    for(int i = v[o].size() - 1; i >= 0; i--) { // this must be sleep
        int t = v[o][i].x;
        if(v[o][i].f) {
            link(edge[t].u, t);
            link(edge[t].v, t);
            Sum += val[t];
        }
        else {
            cut(edge[t].u, t);
            cut(edge[t].v, t);
            Sum -= val[t];
        }
        //printf(" -- > pop %d 
", t);
    }
    v[o].clear();
    return;
}

int main() {

    scanf("%d", &n);
    LL z;
    for(int i = 1, x, y; i < n; i++) {
        scanf("%d%d%lld", &x, &y, &z);
        val[n + i] = z;
        link(x, n + i);
        link(n + i, y);
        edge[n + i].u = x;
        edge[n + i].v = y;
        edge[n + i].val = z;
        Sum += z;
    }
    int m;
    scanf("%d", &m);
    for(int i = 1, l, r; i <= m; i++) {
        int t = 2 * n + i;
        scanf("%d%d%lld%d%d", &edge[t].u, &edge[t].v, &edge[t].val, &l, &r);
        val[t] = edge[t].val;
        add(l, r, t, 1, lm, 1);
    }

    solve(1, lm, 1);

    return 0;
}