Educational Codeforces Round 3 E. Minimum spanning tree for each edge (最小生成树+树链剖分)

题目链接：http://codeforces.com/contest/609/problem/E

给你n个点，m条边。

问枚举每条边，问你加这条边的前提下组成生成树的权值最小的树的权值和是多少。

先求出最小生成树，树链剖分一下最小生成树。然后枚举m条边中的每条边，要是这条边是最小生成树的其中一边，则直接输出最小生成树的答案；否则就用树剖求u到v之间的最大边，然后最小生成树权值减去求出的最大边然后加上枚举的这条边就是答案。

#include <bits/stdc++.h>
using namespace std;
typedef __int64 LL;
const int MAXN = 2e5 + 5;
struct data {
    int from , to , index;
    bool flag;
    LL cost;
    bool operator <(const data& cmp) const {
        return cost < cmp.cost;
    }
}a[MAXN] , b[MAXN];
struct EDGE {
    int next , to;
    LL cost;
}edge[MAXN << 2];
int head[MAXN] , tot;
int par[MAXN] , dep[MAXN] , son[MAXN] , size[MAXN];
int top[MAXN] , id[MAXN] , cnt;

bool cmp(const data& a , const data &b) {
    return a.index < b.index;
}

void init(int n) {
    memset(head , -1 , sizeof(head));
    for(int i = 1 ; i <= n ; ++i)
        par[i] = i;
}

int Find(int u) {
    if(par[u] == u)
        return u;
    return par[u] = Find(par[u]);
}

inline void add(int u , int v , LL cost) {
    edge[tot].to = v;
    edge[tot].next = head[u];
    edge[tot].cost = cost;
    head[u] = tot++; 
}

LL mst(int m) {
    LL sum = 0;
    int f = 0;
    for(int i = 1 ; i <= m ; ++i) {
        int u = Find(a[i].from) , v = Find(a[i].to);
        if(u != v) {
            par[u] = v;
            sum += a[i].cost;
            a[i].flag = true;
            add(a[i].from , a[i].to , a[i].cost);
            add(a[i].to , a[i].from , a[i].cost);
            ++f;
            b[f].from = a[i].from , b[f].to = a[i].to , b[f].cost = a[i].cost;
        }
        else {
            a[i].flag = false;
        }
    }
    return sum;
}

void dfs1(int u , int p , int d) {
    dep[u] = d , par[u] = p , son[u] = u , size[u] = 1;
    for(int i = head[u] ; ~i ; i = edge[i].next) {
        int v = edge[i].to;
        if(v == p)
            continue;
        dfs1(v , u , d + 1);
        if(size[v] >= size[son[u]])
            son[u] = v;
        size[u] += size[v];
    }
}

void dfs2(int u , int p , int t) {
    top[u] = t , id[u] = ++cnt;
    if(son[u] != u)
        dfs2(son[u] , u , t);
    for(int i = head[u] ; ~i ; i = edge[i].next) {
        int v = edge[i].to;
        if(v == son[u] || v == p)
            continue;
        dfs2(v , u , v);
    }
}

struct SegTree {
    int l , r;
    LL Max;
}T[MAXN << 2];

void build(int p , int l , int r) {
    int mid = (l + r) >> 1;
    T[p].l = l , T[p].r = r;
    if(l == r) {
        return ;
    }
    build(p << 1 , l , mid);
    build((p << 1)|1 , mid + 1 , r);
}

void updata(int p , int pos , LL num) {
    int mid = (T[p].l + T[p].r) >> 1;
    if(T[p].l == T[p].r && T[p].l == pos) {
        T[p].Max = num;
        return ;
    }
    if(pos <= mid) {
        updata(p << 1 , pos , num);
    }
    else {
        updata((p << 1)|1 , pos , num);
    }
    T[p].Max = max(T[p << 1].Max , T[(p << 1)|1].Max);
}

LL query(int p , int l , int r) {
    int mid = (T[p].l + T[p].r) >> 1;
    if(T[p].l == l && T[p].r == r) {
        return T[p].Max;
    }
    if(r <= mid) {
        return query(p << 1 , l , r);
    }
    else if(l > mid) {
        return query((p << 1)|1 , l , r);
    }
    else {
        return max(query(p << 1 , l , mid) , query((p << 1)|1 , mid + 1 , r));
    }
}

LL find_max(int u , int v) {
    int fu = top[u] , fv = top[v];
    LL Max = 0;
    while(fv != fu) {
        if(dep[fu] >= dep[fv]) {
            Max = max(Max , query(1 , id[fu] , id[u]));
            u = par[fu];
            fu = top[u];
        }
        else {
            Max = max(Max , query(1 , id[fv] , id[v]));
            v = par[fv];
            fv = top[v];
        }
    }
    if(u == v)
        return Max;
    else if(dep[u] > dep[v])
        return max(Max , query(1 , id[son[v]] , id[u]));
    else
        return max(Max , query(1 , id[son[u]] , id[v]));
}

int main()
{
    int n , m;
    scanf("%d %d" , &n , &m);
    if(m == 0) {
        printf("");
        return 0;
    }
    init(n);
    for(int i = 1 ; i <= m ; ++i) {
        scanf("%d %d %lld" , &a[i].from , &a[i].to , &a[i].cost);
        a[i].index = i;
    }
    sort(a + 1 , a + m + 1);
    LL mst_len = mst(m);
    dfs1(1 , 1 , 0);
    dfs2(1 , 1 , 1);
    build(1 , 2 , cnt);
    for(int i = 1 ; i <= n - 1 ; ++i) {
        if(dep[b[i].from] < dep[b[i].to])
            swap(b[i].from , b[i].to);
        updata(1 , id[b[i].from] , b[i].cost);
    }
    sort(a + 1 , a + m + 1 , cmp);
    for(int i = 1 ; i <= m ; ++i) {
        if(a[i].flag)
            printf("%lld
" , mst_len);
        else {
            LL temp = find_max(a[i].from , a[i].to);
            printf("%lld
" , mst_len - temp + a[i].cost);
        }
    }
    return 0;
}