CF 609E, 树链剖分

题目大意：给你一个联通无向图，问你包含某条边的最小生成树的大小是多少

解：做一个最小生成树，如果询问边在树上，则答案是最小生成树，否则则是这条边+树构成的环上去掉一条最大树边后得到的树。这里用树剖处理即可。

有个sb错误，因为问题是边权，而树剖的链一般是以点为单位，如果采用边权下放到点的技巧的话，注意lca的点权不要计算进来。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <utility>
#include <map>
#include <string>
#include <cmath>
#include <vector>
#include <cstring>
#include <stack>
#include <set>
#include <queue>

using namespace std;

#define SQR(x) ((x)*(x))
#define LL long long
#define LOWBIT(x) ((x)&(-(x)))
#define PB push_back
#define MP make_pair
#define SQR(x) ((x)*(x))
#define LSON(x) ((x)<<1)
#define RSON(x) (((x)<<1)+1)



#define MAXN 211111

const double EPS = 1e-6;

LL ans, spanTree;
int n, m;

struct line{
    int a, b, c, id;
    line(int a = 0, int b = 0, int c = 0, int d = 0): a(a), b(b), c(c), id(d) {}
    bool operator < (const line &rhs) const {
        return c < rhs.c;
    }
};

line a[MAXN];
int w[MAXN];

struct DisjointSet{
    int f[MAXN], n;
    void init(int nn = MAXN - 10) {
        n = nn;
        for (int i = 0; i <= n; ++i) {
            f[i] = i;
        }
    }
    int get(int x) {
        return f[x] == x ? x : f[x] = get(f[x]);
    }
    void joint(int x, int y) {
        f[x] = y;
    }
} DjS;

struct data{
    int dest, cost;
    data *nxt;
    data(int a = 0, int b = 0, data *c = 0): dest(a), cost(b), nxt(c) {}
};

struct TreeArray{
    int tree[MAXN], n;
    int a[MAXN];
    void init(int nn = MAXN - 1) {
        n = nn;
        memset(tree, 0, sizeof(tree[0])*(n+10));
    }
    void add(int x, int num = -1) {
        a[x] = num;
        while (x <= n) {
            tree[x] = max(tree[x], num);
            x += LOWBIT(x);
        }
    }
    int get(int x, int y) {
        int res = -1;
        while (x <= y) {
            if (y - LOWBIT(y) >= x) {
                res = max(res, tree[y]);
                y -= LOWBIT(y);
            } else {
                res = max(res, a[y]);
                --y;
            }
        }
        return res;
    }
} TA;

struct Tree{
    data edge[MAXN*2], *vect[MAXN];
    int n, cnt;
    int sz[MAXN], top[MAXN], heavy[MAXN], father[MAXN], dep[MAXN], lab[MAXN], num;
    int root;
    //???0?4??0?3??0?3??
    void add(int x, int y, int z) {
        edge[++cnt] = data(y, z, vect[x]); vect[x] = &edge[cnt];
    }

    void init(int nn = MAXN - 10, int roott = 1) {
        n = nn;
        cnt = num = 0; 
        memset(vect, 0, sizeof(vect[0])*(n+10));
        memset(father, -1, sizeof(father[0])*(n+10));
        root = roott;
    }

    void split_dfs1(int u = 1) {
        sz[u] = 1; heavy[u] = -1;
        for (data *i = vect[u]; i; i = i->nxt) {
            if (i->dest == father[u]) continue;
            father[i->dest] = u;
            dep[i->dest] = dep[u] + 1;
            w[i->dest] = i->cost;
            split_dfs1(i->dest);
            sz[u] += sz[i->dest];
            if (heavy[u] == -1 || sz[i->dest] > sz[heavy[u]]) heavy[u] = i->dest;
        }
    }

    void split_dfs2(int u = 1, int anc = 1) {
        top[u] = anc; lab[u] = ++num;
        TA.add(lab[u], w[u]);
        if (heavy[u] != -1) split_dfs2(heavy[u], anc);
        for (data *i = vect[u]; i; i = i->nxt) {
            if (i->dest != father[u] && i->dest != heavy[u]) split_dfs2(i->dest, i->dest);
        }
    }

    void split() {
        w[root] = -1;
        dep[root] = 1;
        father[root] = -1;
        
        split_dfs1(root);

        num = 0;

        split_dfs2(root, root);
    }

    int query(int u, int v) {
        int res = -1;
        //cout << "query ================  " << ' '<< endl;
        //cout << u << ' '<< v << endl;
        //cout << top[u] <<' '<< top[v] << endl;
        while (top[u] != top[v]) {
            if (dep[top[u]] < dep[top[v]]) swap(u, v);
            //todo
        //    cout << u << ' '<< v << ' '<< top[u] << ' '<< top[v] << endl;
            res = max(res, TA.get(lab[top[u]], lab[u]));
        //    cout << res << endl;
            //todo end
            u = father[top[u]];
        }
        if (dep[u] > dep[v]) swap(u, v);
        
        //cout << u << ' '<< v << endl;
        //cout << lab[u] << ' ' << lab[v] << endl;
        //todo
        res = max(res, TA.get(lab[u]+1, lab[v]));
        //todo end
        return res;
    }
} G;

void init() {
    cin >> n >> m;
    DjS.init(n);
    G.init(n);
    TA.init(n);

    int x, y, z;
    for (int i = 0; i < m; ++i) {
        cin >> x >> y >> z;
        a[i] = line(x, y, z, i);
    }
    sort(a, a + m);
    int cnt = 0;
    spanTree = 0;
    
    for (int i = 0 ; i < m; ++i) {
        int x = a[i].a, y = a[i].b;
        x = DjS.get(x); y = DjS.get(y);
        if (x != y) {
            //cout << "=============" << endl;
            //cout << a[i].a << ' ' << a[i].b << ' '<< a[i].c << endl;
            DjS.joint(x, y);
            spanTree += a[i].c;
            ++cnt;
            G.add(a[i].a, a[i].b, a[i].c);
            G.add(a[i].b, a[i].a, a[i].c);
            a[i].c *= -1;
        }
        if (cnt + 1 == n) break;
    }
    
    G.split();
    
}

bool cmp2(const line &a, const line &b) {
    return a.id < b.id;
}

void solve() {
    
    //cout << spanTree << endl;
    sort(a, a + m, cmp2);
    ans = 0;
    for (int i = 0; i < m; ++i) {
        if (a[i].c < 0) {
            ans = spanTree;
        }
        else {
            ans = spanTree - G.query(a[i].a, a[i].b) + a[i].c;
            //cout << a[i].a << ' ' << a[i].b << endl;
            //cout << G.query(a[i].a, a[i].b) << ' '<< a[i].c << endl;
        }
        cout << ans << endl;
    }
}

int main() {
    //freopen("test.txt", "r", stdin);
    ios::sync_with_stdio(false);
    init();
    solve();
    return 0;
}