Codeforces 828F Best Edge Weight - 随机堆 - 树差分 - Kruskal - 倍增算法

You are given a connected weighted graph with n vertices and m edges. The graph doesn't contain loops nor multiple edges. Consider some edge with id i. Let's determine for this edge the maximum integer weight we can give to it so that it is contained in all minimum spanning trees of the graph if we don't change the other weights.

You are to determine this maximum weight described above for each edge. You should calculate the answer for each edge independently, it means there can't be two edges with changed weights at the same time.

Input

The first line contains two integers n and m (2 ≤ n ≤ 2·105, n - 1 ≤ m ≤ 2·105), where n and m are the number of vertices and the number of edges in the graph, respectively.

Each of the next m lines contains three integers u, v and c (1 ≤ v, u ≤ n, v ≠ u, 1 ≤ c ≤ 109) meaning that there is an edge between vertices u and v with weight c.

Output

Print the answer for each edge in the order the edges are given in the input. If an edge is contained in every minimum spanning tree with any weight, print -1 as the answer.

Examples

input

4 4
1 2 2
2 3 2
3 4 2
4 1 3

output

2 2 2 1 

input

4 3
1 2 2
2 3 2
3 4 2

output

-1 -1 -1 

---

　　题目大意 给定一个无向连通带权图，求每条边在所有最小生成树中的最大权值(如果可以无限大就输出-1)。

　　对于求1条边在无向连通图带权图的所有最小生成树中的最大权值可以用二分再用Kruskal进行check，但是如果每条边都这么做就会T掉。

　　所以考虑整体二分，然而并不行。

　　所以考虑先跑一遍Kruskal，然后分类讨论一下:

　　1)考虑一条非树边可以取的最大权值。

　　考虑把它加入树中，那么会形成1个环，为了保证最小生成树的边权和最小，方法是删掉环上权值最大的一条边。

　　所以找到它连接的两端在树上形成的简单路径中边权最大的一个，它的边权-1就是这条非树边的答案。

　　这个操作可以用树链剖分或者倍增解决。

　　2)考虑一条树边可以取到的最大权值

　　具体考虑一条树边会比较难做(不过好像有同学设计了时间戳把它搞定了)，但是对于每条非树边都会对它连接的两端在树上形成的简单路径上的所有边有个边权的限制，就是不能超过它的边权 - 1，否则会被它替换掉。

　　这个区间取min操作可以用树链剖分。然而考试的时候我脑子瓦特了，觉得线段树不能区间取min（可能是脑补了一个求和操作）

　　然后想到了只有到最后会一起求得树边的答案，于是想到了差分。

　　为了维护这个最小值，又想到了可并堆。由于要删除，所以可以用下面这个方法构造可删堆(一位dalao的博客提到这个黑科技，我就学习了一下)

　　　　再开一个堆记录要删除的元素，如果两个堆堆顶元素相同，则都弹出堆顶元素。

　　于是便又有一个名为树差分 + 可并堆的zz做法。

Code

/**
 * Codeforces
 * Problem#828F
 * Accepted
 * Time: 420ms
 * Memory: 57864k
 */ 
#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <cctype>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <bitset>
#ifdef WIN32
#define Auto "%I64d"
#else
#define Auto "%lld"
#endif
using namespace std;
typedef bool boolean;
#define ll int
#define smin(_a, _b) _a = min(_a, _b)
#define smax(_a, _b) _a = max(_a, _b)
#define fi first
#define sc second
const signed int inf = (signed) (~0u >> 1);
const signed ll llf = (signed ll) (~0ull >> 1);
typedef pair<int, int> pii;

template<typename T>
inline void readInteger(T& u) {
    static char x;
    while(!isdigit(x = getchar()));
    for(u = x - '0'; isdigit(x = getchar()); u = u * 10 + x - '0');
}

template<typename T>
class Matrix {
    public:
        T* p;
        int row;
        int col;
        Matrix():p(NULL) {        }
        Matrix(int row, int col):row(row), col(col) {
            p = new T[(row * col)];
        }
        
        T* operator [] (int pos) {
            return p + (pos * col);
        }
};
#define matset(a, i, s)    memset(a.p, i, sizeof(s) * a.row * a.col)

typedef class Edge {
    public:
        int u;
        int v;
        int w;
        boolean seced;
        int rid;
        
        Edge(int u = 0, int v = 0, int w = 0):u(u), v(v), w(w), seced(false) {    }

        boolean operator < (Edge b) const {
            return w < b.w;
        }
}Edge;

typedef class Node {
    public:
        int val;
        Node *nxt[2];
        
        Node(int val = inf):val(val) {    nxt[0] = nxt[1] = NULL;    }
}Node;

typedef pair<Node*, Node*> pnn;
#define limit 1000000

Node pool[limit];
Node *top = pool;

Node* newnode(int x) {
    if(top == pool + limit)
        return new Node(x);
    *top = Node(x);
    return top++;
}

Node* merge(Node* &l, Node* r) {
    if(l == NULL)    return r;
    if(r == NULL)    return l;
    if(l->val > r->val)    swap(l, r);
    int p = rand() % 2;
    l->nxt[p] = merge(l->nxt[p], r);
    return l;
}

int n, m;
Edge* edge;
int* res;
int* ans;

inline void init() {
    readInteger(n);
    readInteger(m);
    edge = new Edge[(m + 1)];
    for(int i = 1; i <= m; i++) {
        readInteger(edge[i].u);
        readInteger(edge[i].v);
        readInteger(edge[i].w);
        edge[i].rid = i;
    }
}

int *f;

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

vector<int> *g;
vector<int> *add;
vector<int> *del;

inline void Kruskal() {
    f = new int[(n + 1)];
    g = new vector<int>[(n + 1)];
    for(int i = 1; i <= n; i++)
        f[i] = i;
    sort(edge + 1, edge + m + 1);
    int fin = 0;
    for(int i = 1; i <= m && fin < n - 1; i++) {
        if(find(edge[i].u) != find(edge[i].v)) {
            f[find(edge[i].u)] = find(edge[i].v);
            g[edge[i].u].push_back(i);
            g[edge[i].v].push_back(i);
            edge[i].seced = true;
            fin++;
        }
    }
}

const int BZMAX = 18;
int* dep;
Matrix<int> bz;
Matrix<int> bzm;

void dfs1(int node, int fa, int lastv) {
    dep[node] = dep[fa] + 1;
    bz[node][0] = fa;
    bzm[node][0] = lastv;
    for(int i = 1; i < BZMAX; i++)
        bz[node][i] = bz[bz[node][i - 1]][i - 1], bzm[node][i] = max(bzm[node][i - 1], bzm[bz[node][i - 1]][i - 1]);
    for(int i = 0; i < (signed)g[node].size(); i++) {
        if(!edge[g[node][i]].seced)    continue;
        int e = (edge[g[node][i]].u == node) ? (edge[g[node][i]].v) : (edge[g[node][i]].u);
        if(e == fa)    continue;
        dfs1(e, node, edge[g[node][i]].w);
    }
}

pii lca(int u, int v) {
    if(dep[u] < dep[v])    swap(u, v);
    int rtmax = 0;
    int ca = dep[u] - dep[v];
    for(int i = 0; i < BZMAX; i++)
        if(ca & (1 << i)) {
            smax(rtmax, bzm[u][i]);
            u = bz[u][i];
        }
    if(u == v)    return pii(u, rtmax);
    for(int i = BZMAX - 1; ~i; i--) {
        if(bz[u][i] != bz[v][i]) {
            smax(rtmax, bzm[u][i]);
            smax(rtmax, bzm[v][i]);
            u = bz[u][i];
            v = bz[v][i];
        }
    }
    smax(rtmax, bzm[u][0]);
    smax(rtmax, bzm[v][0]);
    return pii(bz[u][0], rtmax);
}

pair<Node*, Node*> dfs2(int node, int fa, int tofa) {
    Node* rt = NULL;
    Node* dl = NULL;
    for(int i = 0; i < (signed)g[node].size(); i++) {
        if(!edge[g[node][i]].seced)    continue;
        int e = (edge[g[node][i]].u == node) ? (edge[g[node][i]].v) : (edge[g[node][i]].u);
        if(e == fa)    continue;
        pnn ap = dfs2(e, node, g[node][i]);
        rt = merge(rt, ap.fi);
        dl = merge(dl, ap.sc);
    }
    for(int i = 0; i < (signed)add[node].size(); i++)
        rt = merge(rt, newnode(add[node][i]));
    for(int i = 0; i < (signed)del[node].size(); i++)
        dl = merge(dl, newnode(del[node][i]));
    while(dl && rt->val == dl->val) {
        rt = merge(rt->nxt[0], rt->nxt[1]);
        rt = merge(rt->nxt[0], rt->nxt[1]);
        dl = merge(dl->nxt[0], dl->nxt[1]);
    }
    res[tofa] = (!rt) ? (-1) : (rt->val);
    return pnn(rt, dl);
}

inline void solve() {
    res = new int[(m + 1)];
    dep = new int[(n + 1)];
    bz = Matrix<int>(n + 1, BZMAX);
    bzm = Matrix<int>(n + 1, BZMAX);
    dep[0] = 0;
    for(int i = 0; i < BZMAX; i++)
        bz[0][i] = bzm[0][i] = 0;
    dfs1(1, 0, 0);
    add = new vector<int>[(n + 1)];
    del = new vector<int>[(n + 1)];
    for(int i = 1; i <= m; i++) {
        if(edge[i].seced)    continue;
        int u = edge[i].u, v = edge[i].v;
        pii l = lca(u, v);
        res[i] = l.sc - 1;
        add[u].push_back(edge[i].w - 1);
        add[v].push_back(edge[i].w - 1);
        del[l.fi].push_back(edge[i].w - 1);
    }
    dfs2(1, 0, 0);
    ans = new int[(m + 1)];
    for(int i = 1; i <= m; i++)
        ans[edge[i].rid] = res[i];
    for(int i = 1; i <= m; i++)
        printf("%d ", ans[i]);
}

int main() {
    srand(233);
    init();
    Kruskal();
    solve();
    return 0;
}