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;
}