CodeForces 827D Round #423 Div2F&Div1D：LCA+路径压缩+MST（最小生成树）

题意：给出一张n(<=2e5)个点 m（<=2e5）条边无向图，保证有生成树。对于每条边，给出一个最大值maxLength，咦即能够保证这条边能够出现在所有的最小生成树中，边权的最大值为maxLength（同时，其他所有边长度不变）。给出所有m个答案。如果一条边无论边权是多大，都出现在所有最小生成树中，则输出-1.

题解：既然是生成树相关问题，那么我们先考虑图中任意一个MST，按照kruskal算法，MST可以这样得到：按边权排序，加入m-1条端点不在一个并查集的边。这样一来的话，所有的m条边分成两种：一、MST上的边，显然这些边需要满足这样的性质：不能够太长，以至于被替换出MST。二、非MST上的边，这部分边的答案要满足性质：要变小一些，是的进入MST中，考虑已经有的这个MST，非MST边的两个端点u，v：如果说这条连接uv的边进入MST中，那么就出现一个环，于是要在这个环上破除一条最长的边，才能得到MST，而我们希望这条非MST边进入MST中，那么他不能再是最长边了，他最大只能是是这个环上最长边-1，于是思路就来了：u和v做一次lca得到ancestor，然后可以通过st倍增的方式快速找到u-ancestor和v-ancestor边权极大值M，那么这条非MST边的答案就是M-1.同时呢，我们想，这个u-v的这个经过lca的简单道路，他上边的MST边其实都受到了这条边的威胁，那么为了保证不被替换掉，必须要保证一条MST边，都小于所有能够威胁到他的边。所以我们要用这条非MST边的边权K，减去1来更新以下lca道路上每条边的答案。

于是我们的算法其实只需要针对非MST边，先求出LCA，然后st求出路径上的最长边，并且再把整条道路的答案维护一下就OK。

注意：每条MST边，要st一次，复杂度是常数（20左右），而把u-v的路径遍历一次理论上最坏复杂度是O(n)，于是会TLE。这里有一个优化，我们在kruskal的算法中，已经按照边权排序，那么假设之前某次有一条非MST边的更新路径和当前考虑的非MST边的更新路径有交集，交集部分是不需要更新的。因为这部分交集边同时需要满足小于K1和K2，而先前的K1一定比K2小，那么可以把这一段路径压缩起来，不再更新。类似于并查集的father数组。更新过u-lca-v的路径之后，把所有节点的link置为lca。

Code:

#include<bits/stdc++.h>
using namespace std;
#define MAXN 200005
const int INF =  0x3f3f3f3f; 
struct Edge{
    int start,des,length,id;
//    bool operator <(Edge* a){
//        return (des<a->des);
//    }
    bool operator < (const Edge& rhs) const { return length < rhs.length; }
};
Edge allE[MAXN];
vector <Edge> E[MAXN];
vector <Edge> remainE;
int father[MAXN];
int fa [MAXN][20];
int maxLength [MAXN][20];
int depth [MAXN];
int ans [MAXN];
int n,m;
int upperE[MAXN];
int link [MAXN];
int cheat;
//int upperLength[MAXN];
int findFather (int x){
    return father[x]==x?x:father[x] = findFather (father[x]);
}
void buildTree(int nod,int dad,int deep){
    depth[nod] = deep;
    for (vector<Edge>::iterator it = E[nod].begin();it!=E[nod].end();it++){
        if (it->des==dad){
            continue;
        }
        fa[it->des][0] = nod;
        upperE[it->des] = it->id;
        maxLength[it->des][0] = it->length; 
        buildTree(it->des,nod,deep+1);
    }
}
int lca(int a,int b){
    if (a==b){
        return a;
    }
    if (depth[a]<depth[b]){
        swap(a,b);
    }
    for (int i=18;i>=0;i--){
        if (fa[a][i]!=0&&depth[fa[a][i]]>=depth[b]){
            a = fa[a][i];
        }
    }
    for (int i=18;i>=0;i--){
        if (a==b){
            return a;
        }
        if (fa[a][i]!=fa[b][i]){
            a = fa[a][i];
            b = fa[b][i];
        }
    }
    return fa[a][0];
}
void initST(){
//    for (int i=1;i<=n;i++){
//        if (upperE[i]!=0){
//            maxLength[i][0] = allE
//        }
//    }
    for (int i=1;i<18;i++){
        for (int j = 1;j<=n;j++){
            if (fa[j][i-1]!=0){
                fa[j][i] = fa[fa[j][i-1]][i-1];
                maxLength[j][i] = max(maxLength[j][i-1],maxLength[fa[j][i-1]][i-1]);                
            }
        }
    }
}
int maxQuery(int nod,int ca){
    int ans = 0;
    for (int i=18;i>=0;i--){
        if (fa[nod][i]!=0&&depth[fa[nod][i]]>=depth[ca]){
            ans = max(ans,maxLength[nod][i]);
            nod = fa[nod][i];
        }
    }
    return ans;
}
int adjust(int nod,int ca,int tempAns){
    if (depth[nod]<=depth[ca])return ca;
    ans[upperE[nod]] = min(ans[upperE[nod]],tempAns);
    link[nod] = adjust(link[fa[nod][0]],ca,tempAns);
}
int main(){
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++){
        int u,v,c;
        scanf("%d%d%d",&u,&v,&c);
        if (cheat==0){
            cheat = u;
        }
        Edge e;
        e.start = u,e.des = v,e.length = c,e.id = i;
        allE[i] = e;
    } 
    for (int i=1;i<=n;i++){
        father[i]=i;
        link[i]=i;
    }
    sort(allE+1,allE+m+1);
    for (int i=1;i<=m;i++){
        Edge e = allE[i];
        int a = e.start,b = e.des,c = e.length,id = e.id;
        int fa = findFather(a),fb = findFather(b);
        if (fa == fb){
            remainE.push_back(e);
        }else{
            Edge newE;
            newE.des=a,newE.length = c,newE.id = id;
            E[b].push_back(newE);
            newE.des = b;
            E[a].push_back(newE);
            father[findFather(a)] = findFather(b); 
        }
    }
//    for (vector<Edge>::iterator it = remainE.begin();it!=remainE.end();it++){
//        cout<<it->id<<endl;
//    }

    buildTree(1,0,1);
    for (int i=1;i<=m;i++){
        ans[i] = INF;
    }
    initST();
//    if (cheat==58480){
//        return 0;
//    }
//    for (int i=1;i<=n;i++){
//        cout<<"maxLength["<<i<<"][1]="<<maxLength[i][1]<<endl;
//    }
    for (vector<Edge>::iterator it = remainE.begin();it!=remainE.end();it++){
        int temp = lca(it->start,it->des);
        int tempMax = max(maxQuery(it->start,temp),maxQuery(it->des,temp));
        ans[it->id] = tempMax-1;
        adjust(it->start,temp,it->length-1);
        adjust(it->des,temp,it->length-1);
    }
    for (int i=1;i<=m;i++){
        if (ans[i]==INF){
            printf("-1 ");
        }else{
            printf("%d ",ans[i]);
        }
    }
    return 0;
}