codeforces 609E. Minimum spanning tree for each edge 树链剖分

题目链接

给一个n个节点m条边的树， 每条边有权值， 输出m个数， 每个数代表包含这条边的最小生成树的值。

先将最小生成树求出来， 把树边都标记。 然后对标记的边的两个端点， 我们add(u, v), add(v, u)。 对于每一次输出， 如果这条边被标记了， 那么直接输出mst的值。 否则， 加上这条边之后一定会出现一个环， 我们就把环上的最长的那条边删掉。 查询最长的那条边可以用树链剖分。

#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <queue>
#include <stack>
#include <bitset>
using namespace std;
#define pb(x) push_back(x)
#define ll long long
#define mk(x, y) make_pair(x, y)
#define lson l, m, rt<<1
#define mem(a) memset(a, 0, sizeof(a))
#define rson m+1, r, rt<<1|1
#define mem1(a) memset(a, -1, sizeof(a))
#define mem2(a) memset(a, 0x3f, sizeof(a))
#define rep(i, n, a) for(int i = a; i<n; i++)
#define fi first
#define se second
typedef pair<int, int> pll;
const double PI = acos(-1.0);
const double eps = 1e-8;
const int mod = 1e9+7;
const int inf = 1061109567;
const int dir[][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} };
const int maxn = 2e5+5;
int head[maxn*2], son[maxn], sz[maxn], deep[maxn], top[maxn], w[maxn], f[maxn], cnt, num;
int maxx[maxn<<2], fa[maxn];
struct node
{
    int to, nextt;
}e[maxn*2];
struct ed
{
    int u, v, id, val, mark;
    ed(){}
    ed(int u, int v, int val, int id, int mark = 0):u(u), v(v), val(val), id(id), mark(mark){}
}edge[maxn];
bool cmp1(ed a, ed b) {
    return a.id<b.id;
}
bool cmp2(ed a, ed b) {
    if(a.val == b.val)
        return a.id<b.id;
    return a.val<b.val;
}
void init() {
    mem1(head);
    num = cnt = 0;
}
void add(int u, int v, int w) {
    e[num].to = v, e[num].nextt = head[u], head[u] = num++;
}
void dfs1(int u, int fa) {
    sz[u] = 1;
    deep[u] = deep[fa]+1;
    son[u] = -1;
    f[u] = fa;
    for(int i = head[u]; ~i; i = e[i].nextt) {
        int v = e[i].to;
        if(v == fa)
            continue;
        dfs1(v, u);
        sz[u] += sz[v];
        if(son[u]==-1||sz[v]>sz[son[u]])
            son[u] = v;
    }
}
void dfs2(int u, int tp) {
    w[u] = ++cnt, top[u] = tp;
    if(~son[u])
        dfs2(son[u], tp);
    for(int i = head[u]; ~i; i = e[i].nextt) {
        int v = e[i].to;
        if(v == f[u]||v == son[u])
            continue;
        dfs2(v, v);
    }
}
void pushUp(int rt) {
    maxx[rt] = max(maxx[rt<<1], maxx[rt<<1|1]);
}
void update(int p, int val, int l, int r, int rt) {
    if(l == r) {
        maxx[rt] = val;
        return ;
    }
    int m = l+r>>1;
    if(p<=m)
        update(p, val, lson);
    else
        update(p, val, rson);
    pushUp(rt);
}
int query(int L, int R, int l, int r, int rt) {
    if(L<=l&&R>=r) {
        return maxx[rt];
    }
    int m = l+r>>1, ret = 0;
    if(L<=m)
        ret = max(ret, query(L, R, lson));
    if(R>m)
        ret = max(ret, query(L, R, rson));
    return ret;
}
int find(int u, int v) {
    int f1 = top[u], f2 = top[v], ret = 0;
    while(f1 != f2) {
        if(deep[f1]<deep[f2]) {
            swap(f1, f2);
            swap(u, v);
        }
        ret = max(ret, query(w[f1], w[u], 1, cnt, 1));
        u = f[f1];
        f1 = top[u];
    }
    if(u == v)
        return ret;
    if(deep[u]>deep[v])
        swap(u, v);
    return max(ret, query(w[son[u]], w[v], 1, cnt, 1));
}
int findd(int u) {
    return fa[u] == u?u:fa[u] = findd(fa[u]);
}
int main()
{
    int t, n, u, v, val, m;
    while(~scanf("%d%d", &n, &m)) {
        init();
        ll mst = 0;
        deep[0] = 0;
        for(int i = 1; i<=m; i++) {
            scanf("%d%d%d", &u, &v, &val);
            edge[i] = ed(u, v, val, i);
        }
        for(int i = 1; i<=n; i++)
            fa[i] = i;
        sort(edge+1, edge+1+m, cmp2);
        for(int i = 1; i<=m; i++) {
            u = findd(edge[i].u);
            v = findd(edge[i].v);
            if(u == v)
                continue;
            edge[i].mark = 1;
            fa[v] = u;
            mst += edge[i].val;
        }
        for(int i = 1; i<=m; i++) {
            if(edge[i].mark) {
                add(edge[i].u, edge[i].v, edge[i].val);
                add(edge[i].v, edge[i].u, edge[i].val);
            }
        }
        dfs1(1, 0);
        dfs2(1, 1);
        for(int i = 1; i<=m; i++) {
            if(deep[edge[i].u]>deep[edge[i].v]) {
                swap(edge[i].u, edge[i].v);
            }
            if(edge[i].mark)
                update(w[edge[i].v], edge[i].val, 1, cnt, 1);
        }
        sort(edge+1, edge+1+m, cmp1);
        for(int i = 1; i<=m; i++) {
            if(edge[i].mark) {
                printf("%I64d
", mst);
            } else {
                int tmp = find(edge[i].u, edge[i].v);
                printf("%I64d
", mst-tmp+edge[i].val);
            }
        }
    }
    return 0;
}