noip2019集训测试赛（三）C.MST

Description

给定一个n个点m条边的连通图，保证没有自环和重边。对于每条边求出,在其他边权值不变的情况下,它能取的最大权值，使得这条边在连通图的所有最小生成树上。假如最大权值为无限大，则输出-1。

---

Input

第一行两个整数n,m，表示n个点m条边

接下来m行，每行3个整数x,y,z，表示节点x和节点y之间有一条长z的边

---

Output

输出一行m个整数，表示每条边的答案

---

Solution

一道关于最小生成树和倍增的好题。

首先要知道最小生成树是什么及其求法。
先求一遍最小生成树，得到所有最小生成树的边。

对于每一条边 x：

• 若x是最小生成树的边，那么x并不用更新自身，且也无法对非树边造成贡献。
  （先不用想为什么，下面会解释）

• 若x是非树边，那么需要做两个操作：

1. 利用倍增来求得 该点所在环的 是树边的边 的边权最大值maxs，若要使得x必在最小生成树上，即要使x的权值小于环上最大边权，易知$x_{max}=maxs-1$。

   此时若x是树边，因为已经在树上，不用更新。

2. 做完1操作还不够，我们还要考虑该边对其他边答案的贡献：
   若x的边权小于另一条边y的边权，为什么要选择y而不选择x呢？
   所以对于x所在环上的所有y有$y_{max}=min(dis(x),y_{max})$。

   这里有一个优化：
   把边按边权从小到大排序，若某条边已经被更新，再更新就是多余的。
   所以我们可以使用并查集的路径压缩思想，跳过中间已被更新的边。

   若x是树边，那么应对非树边没有任何贡献，因为他们不是竞争关系而是替换关系。

---

Code

#include<bits/stdc++.h> 
using namespace std;
int n,m,cnt=0;
int head[200010],ans[200010];
int fa[200010],dep[200010],id[200010];
int f[200010][20],maxn[200010][20];
bool vis[200010];
struct data{
    int x,y,dis,id;
    bool operator <(const data &a)const{
    	return dis<a.dis;
	} 
}a[200010];
struct edge{
    int x,dis,nxt,id;
}e[400010];
inline void add(int x,int y,int z,int id){
    e[++cnt].x=y;
	e[cnt].dis=z;
	e[cnt].id=id;
    e[cnt].nxt=head[x];
	head[x]=cnt;
}
int find(int x){
    if(fa[x]==x) return fa[x];
    return fa[x]=find(fa[x]);
}
void build(){
    sort(a+1,a+m+1);
    for(int i=1;i<=n;i++) fa[i]=i;
    for(int i=1;i<=m;i++){
        int x=a[i].x,y=a[i].y;
        int fx=find(x),fy=find(y);
        if(fx!=fy){
            fa[fy]=fx;
            vis[a[i].id]=true;
            add(x,y,a[i].dis,a[i].id);
            add(y,x,a[i].dis,a[i].id);
        }
    }
}
void dfs(int x){
    for(int i=1;i<=18;i++){
        f[x][i]=f[f[x][i-1]][i-1];
        maxn[x][i]=max(maxn[x][i-1],maxn[f[x][i-1]][i-1]);
    }
    for(int i=head[x];i;i=e[i].nxt)
	if(e[i].x!=f[x][0]){
        f[e[i].x][0]=x;
        id[e[i].x]=e[i].id;
        dep[e[i].x]=dep[x]+1;
        maxn[e[i].x][0]=e[i].dis;
        dfs(e[i].x);
    }
}
void solve(int x,int y,int dis){
    x=find(x);
    while(dep[x]>dep[y]){
        ans[id[x]]=min(ans[id[x]],dis-1);
        int k=find(f[x][0]);
        fa[x]=k,x=find(x);//路径压缩
    }
}
int get(int x,int y,int &lca){
    int ans=0;
    if(dep[x]<dep[y]) swap(x,y);
    for(int i=18;i>=0;i--)//倍增求maxs
        if(dep[f[x][i]]>=dep[y]){
            ans=max(ans,maxn[x][i]);
            x=f[x][i];
        }
    if(x==y){
        lca=x;
        return ans;
    }
    for(int i=18;i>=0;i--){
        if(f[x][i]!=f[y][i]){
            ans=max(ans,maxn[x][i]);
            ans=max(ans,maxn[y][i]);
            x=f[x][i],y=f[y][i];
        }
    }
    lca=f[x][0];
    return max(ans,max(maxn[x][0],maxn[y][0]));
}
inline int read(){
	char c=getchar(); int x=0,f=1;
    while(!isdigit(c) && c!='-') c=getchar();
    if(c=='-') { f=-1; c=getchar(); }
    while(isdigit(c)) { x=(x<<3)+(x<<1)+c-'0'; c=getchar(); }
    return x*f;
}
int main(){
    n=read(),m=read();
    for(int i=1;i<=m;i++){
        a[i].x=read(),a[i].y=read(),a[i].dis=read();
        ans[i]=2e9; a[i].id=i;
    }
    build(),dfs(1);
    for(int i=1;i<=n;i++) fa[i]=i;
    for(int i=1;i<=m;i++)
	if(!vis[a[i].id]){//即非树边
        int x=a[i].x,y=a[i].y,z;
        ans[a[i].id]=get(x,y,z)-1;
        solve(x,z,a[i].dis); //这里将环分割成x~lca和y~lca两部分。
        solve(y,z,a[i].dis);
    }
    for(int i=1;i<=m;i++){
        if(ans[i]==2e9) printf("-1 ");
        else printf("%d ",ans[i]);
    }
}