Codeforces Round #111 (Div. 2) D.Edges in MST(最小生成树+桥 MST必要边/可行边/不可行边)

题目

n(n<=1e5)个点，m(n-1<=m<=min(1e5,n*(n-1)/2)条边的无向图，不含重边和自环

第i条边的权值为wi(1<=wi<=1e6)，

对于每条边，判断其为最小生成树中的必要边/可行边/不可行边

即，一定出现在所有MST中，可能出现在某一个MST中，不可能出现在任意一个MST中

思路来源

https://www.cnblogs.com/Hugh-Locke/p/9622936.html

题解

Kruskal求最小生成树，将相同权值的边(u,v,w)放在一起考虑，

记x=find(u),y=find(v)，即祖先，

①若x==y，说明已成环，这条边必不在最小生成树中，

②否则，说明这条边可能在某棵MST中，对这样的祖先x和y之间连边，

实际可理解为对并查集内的点缩点，缩成内部可达的一个点，两个集合之间可通过这一条边连通，

若a集合和b集合能通过至少两条边连在一起，即说明这两条边均不必要，

③若只能通过一条边连通两个集合，则必要，这就是双连通分量里的桥，

于是根据并查集 的根x与根y的关系，临时建图，dfs一下，判断边是不是桥即可

 

注意到求桥的过程中，新建的图可能含重边，

用判父亲节点是从哪一条边转移过来的方式，来区分反向边

代码

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
#define pb push_back
#define fi first
#define se second
#define sci(a) scanf("%d",&(a))
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
typedef pair<int,int> P;
struct edge{
    int u,v,w,id;
    bool operator<(const edge &x){
        return w<x.w;
    }
}f[N];
int n,m,u,v,x,y,w,par[N],ans[N];
int low[N],dfn[N],tot;
vector<P>e[N];
int find(int x){
    return par[x]==x?x:par[x]=find(par[x]);
}
void add(int x,int y,int id){
    e[x].pb(P(y,id));
    e[y].pb(P(x,id));
}
void unite(int x,int y){
    x=find(x),y=find(y);
    if(x==y)return;
    par[y]=x;
}
void dfs(int u,int in){//含重边的求桥法 必记录上一条边的边号 不能反向边回去
    low[u]=dfn[u]=++tot;
    for(P x:e[u]){
        int v=x.fi,id=x.se;
        if(!dfn[v]){
            dfs(v,id);
            low[u]=min(low[u],low[v]);
            if(low[v]>dfn[u]){
                ans[f[id].id]=2;//桥边 必在
            }
        }
        else if(id!=in)//不是反向边
        low[u]=min(low[u],dfn[v]);
    }
}
int main(){
    sci(n),sci(m);
    rep(i,1,n){
        par[i]=i;
    }
    rep(i,1,m){
        sci(u),sci(v),sci(w);
        f[i]=edge{u,v,w,i};
    }
    sort(f+1,f+m+1);
    rep(i,1,m){
        w=f[i].w;
        int j=i;
        while(j+1<=m && f[j+1].w==f[i].w)j++;
        now.clear();
        ver.clear();
        rep(k,i,j){
            //printf("k:%d\n",k);
            u=find(f[k].u),v=find(f[k].v);
            if(u==v){
                ans[f[k].id]=-1;//必不在最小生成树中
                continue;
            }
            else{
                ans[f[k].id]=1;//可能在
                if(!e[u].empty())e[u].clear(),dfn[u]=0;
                if(!e[v].empty())e[v].clear(),dfn[v]=0;
            }
        }
        rep(k,i,j){//对不在同一分量的rt建边
            u=find(f[k].u),v=find(f[k].v);
            if(u==v){
                continue;
            }
            add(u,v,k);
            add(v,u,k);
        }
        tot=0;
        rep(k,i,j){//若u-v之间无边说明在同一分量 否则只dfs(u)求桥即可
            u=find(f[k].u);
            if(!dfn[u]){
                dfs(u,0);
            }
        }
        rep(k,i,j){//正常建MST
            u=find(f[k].u),v=find(f[k].v);
            unite(u,v);
        }
        i=j;
    }
    rep(i,1,m){
        if(ans[i]==2)puts("any");
        else if(ans[i]==-1)puts("none");
        else puts("at least one");
    }
    return 0;
}