Codeforces Edu3 E. Minimum spanning tree for each edge

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Connected undirected weighted graph without self-loops and multiple edges is given. Graph contains n vertices and m edges.

For each edge (u, v) find the minimal possible weight of the spanning tree that contains the edge (u, v).

The weight of the spanning tree is the sum of weights of all edges included in spanning tree.

Input

First line contains two integers n and m (1 ≤ n ≤ 2·105, n - 1 ≤ m ≤ 2·105) — the number of vertices and edges in graph.

Each of the next m lines contains three integers ui, vi, wi (1 ≤ ui, vi ≤ n, ui ≠ vi, 1 ≤ wi ≤ 109) — the endpoints of the i-th edge and its weight.

Output

Print m lines. i-th line should contain the minimal possible weight of the spanning tree that contains i-th edge.

The edges are numbered from 1 to m in order of their appearing in input.

Sample test(s)

input

output

9
8
11
8
8
8
9

题意：给你一个n个点，m条边的无向图。对于每一条边，求包括该边的最小生成树
我们首先想到的是，求一次整图的MST后，对于每一条边(u,v)，如果该边在整图的最小生成树上，答案就是MST，否则，加入的边(u,v)就会使原来的最小生成树成环，可以通过LCA确定该环，那么我们只要求出点u到LCA(u,v)路径上的最大边权和v到LCA(u,v)路径上的最大边权中的最大值mx，MST - mx + w[u,v]就是答案了
其中gx[u][i]表示节点u到其第2^i个祖先之间路径上的最大边权

#include <bits/stdc++.h>

using namespace std;

const int INF = 0x3f3f3f3f;

const int N = 2e5 + ;

const int DEG = ;

typedef long long ll;

struct edge {

    int v, w, next;

    edge() {}

    edge(int v, int w, int next) : v(v), w(w), next(next){}

}e[N << ];

int head[N], tot;

int fa[N][DEG], deg[N];

int gx[N][DEG];

void init() {

    memset(head, -, sizeof head);

    tot = ;

}

void addedge(int u, int v, int w) {

    e[tot] = edge(v, w, head[u]);

    head[u] = tot++;

}

void BFS(int root) {

    queue<int> que;

    deg[root] = ;

    fa[root][] = root;

    gx[root][] = ;

    que.push(root);

    while(!que.empty()) {

        int tmp = que.front();

        que.pop();

        for(int i = ; i < DEG; ++i) {

            fa[tmp][i] = fa[ fa[tmp][i - ] ][i - ];

            gx[tmp][i] = max(gx[tmp][i - ], gx[ fa[tmp][i - ] ][i - ]);

          // printf("[%d %d] ", tmp, gx[tmp][i]);

        }

       // puts("");

        for(int i = head[tmp]; ~i; i = e[i].next) {

            int v = e[i].v;

            int w = e[i].w;

            if(v == fa[tmp][]) continue;

            deg[v] = deg[tmp] + ;

            fa[v][] = tmp;

            gx[v][] = w;

            que.push(v);

        }

    }

}

int Mu, Mv;

ll LCA(int u, int v) {

    Mu = Mv = -;

    if(deg[u] > deg[v]) swap(u, v);

    int hu = deg[u], hv = deg[v];

    int tu = u, tv = v;

    for(int det = hv - hu, i = ; det; det >>= , ++i)

        if(det & ) { Mv = max(Mv, gx[tv][i]); tv = fa[tv][i];  }

    if(tu == tv) return Mv;

    for(int i = DEG - ; i >= ; --i) {

        if(fa[tu][i] == fa[tv][i]) continue;

        Mu = max(Mu, gx[tu][i]);

        Mv = max(Mv, gx[tv][i]);

        tu = fa[tu][i];

        tv = fa[tv][i];

    }

    return max(max(Mu, gx[tu][]), max(Mv, gx[tv][]));

}

int U[N], V[N], w[N], r[N], f[N];

int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }

bool cmp(int a, int b) { return w[a] < w[b]; }

ll MST;

int n, m;

void mst() {

    scanf("%d%d", &n, &m);

    for(int i = ; i <= m; ++i) {

        scanf("%d%d%d", &U[i], &V[i], &w[i]);

        r[i] = i;

        f[i] = i;

    }

    sort(r + , r + m + , cmp);

    MST = ;

    for(int i = ; i <= m; ++i)

    {

        int id = r[i];

        int fu = find(U[id]);

        int fv = find(V[id]);

        if(fu != fv) {

            MST += w[id];

            f[ fu ] = fv;

            addedge(U[id], V[id], w[id]);

            addedge(V[id], U[id], w[id]);

        }

    }

}

int main() {

    init();

    mst();

    BFS();

    for(int i = ; i <= m; ++i) {

        printf("%I64d\n", MST - LCA(U[i], V[i]) + w[i]);

    }

    return ;

}