[CF160D]Edges in MST

[CF160D]Edges in MST

题目大意：

一个\(n(n\le10^5)\)个点，\(m(m\le10^5)\)条边的连通图。对于图中的每条边，判断它与该图最小生成树的关系：

1. 在该图所有的最小生成树中；
2. 在该图至少一个最小生成树中；
3. 不在该图的任何一个最小生成树中。

思路：

首先用Kruskal求出该图其中一个最小生成树。枚举每一条不在树内的边，考虑在生成树上加入这条边所构成的环。若环上有权值与该边相同的边，则这些边都是可以互相替换的，都属于第\(2\)类关系。若环上所有边的权值都比该边小，则说明包含该边的生成树不是最小的，属于第\(3\)类关系。判断完所有的\(2\)、\(3\)类关系后，生成树中剩下的边即为\(1\)类边。显然加入非树边时，环上不存在权值大于该非树边的边，否则与最小生成树矛盾。因此可以考虑使用树链剖分和线段树维护最大值。时间复杂度\(\mathcal O((n+m)\log n)\)。

源代码：

#include<cstdio>
#include<cctype>
#include<numeric>
#include<algorithm>
#include<forward_list>
inline int getint() {
    register char ch;
    while(!isdigit(ch=getchar()));
    register int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
constexpr int N=1e5+1,M=1e5;
struct Edge {
    int u,v,w,id;
    bool operator < (const Edge &rhs) const {
        return w<rhs.w;
    }
};
Edge edge[M];
struct Edge2 {
    int to,w,id;
};
std::forward_list<Edge2> e[N];
inline void add_edge(const int &u,const int &v,const int &w,const int &id) {
    e[u].emplace_front((Edge2){v,w,id});
    e[v].emplace_front((Edge2){u,w,id});
}
class DisjointSet {
    private:
        int anc[N];
        int find(const int &x) {
            return x==anc[x]?x:anc[x]=find(anc[x]);
        }
    public:
        void reset(const int &n) {
            std::iota(&anc[1],&anc[n]+1,1);
        }
        void merge(const int &x,const int &y) {
            anc[find(x)]=find(y);
        }
        bool same(const int &x,const int &y) {
            return find(x)==find(y);
        }
};
DisjointSet s;
bool vis[M];
int par[N],dep[N],top[N],son[N],size[N],dfn[N],eid[N],w[N];
void dfs1(const int &x,const int &par) {
    size[x]=1;
    ::par[x]=par;
    dep[x]=dep[par]+1;
    for(auto &j:e[x]) {
        const int &y=j.to;
        if(y==par) continue;
        dfs1(y,x);
        size[x]+=size[y];
        if(size[y]>size[son[x]]) {
            son[x]=y;
        }
    }
}
void dfs2(const int &x,const int &id,const int &w) {
    dfn[x]=++dfn[0];
    eid[dfn[x]]=id;
    ::w[dfn[x]]=w;
    top[x]=x==son[par[x]]?top[par[x]]:x;
    for(auto &j:e[x]) {
        const int &y=j.to;
        if(y==son[x]) {
            dfs2(y,j.id,j.w);
        }
    }
    for(auto &j:e[x]) {
        const int &y=j.to;
        if(y==par[x]||y==son[x]) continue;
        dfs2(y,j.id,j.w);
    }
}
int type[M];
class SegmentTree {
    #define _left <<1
    #define _right <<1|1
    private:
        int max[N<<2],tag[N<<2];
        void push_up(const int &p) {
            max[p]=std::max(max[p _left],max[p _right]);
        }
        void push_down(const int &p) {
            if(!tag[p]) return;
            if(max[p _left]==max[p]) tag[p _left]=tag[p];
            if(max[p _right]==max[p]) tag[p _right]=tag[p];
            tag[p]=0;
        }
    public:
        void build(const int &p,const int &b,const int &e) {
            if(b==e) {
                max[p]=w[b];
                return;
            }
            const int mid=(b+e)>>1;
            build(p _left,b,mid);
            build(p _right,mid+1,e);
            push_up(p);
        }
        int query(const int &p,const int &b,const int &e,const int &l,const int &r) {
            if(b==l&&e==r) return max[p];
            const int mid=(b+e)>>1;
            int ret=0;
            if(l<=mid) ret=std::max(ret,query(p _left,b,mid,l,std::min(mid,r)));
            if(r>mid) ret=std::max(ret,query(p _right,mid+1,e,std::max(mid+1,l),r));
            return ret;
        }
        void mark(const int &p,const int &b,const int &e,const int &l,const int &r,const int &w,const int &t) {
            if(b==l&&e==r&&max[p]==w) {
                tag[p]=t;
                return;
            }
            push_down(p);
            const int mid=(b+e)>>1;
            if(l<=mid&&max[p _left]>=w) mark(p _left,b,mid,l,std::min(mid,r),w,t);
            if(r>mid&&max[p _right]>=w) mark(p _right,mid+1,e,std::max(mid+1,l),r,w,t);
        }
        void stat(const int &p,const int &b,const int &e) {
            if(b==e) {
                type[eid[b]]=tag[p];
                return;
            }
            push_down(p);
            const int mid=(b+e)>>1;
            stat(p _left,b,mid);
            stat(p _right,mid+1,e);
        }
    #undef _left
    #undef _right
};
SegmentTree t;
inline int get_max(int x,int y) {
    int max=0;
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]]) std::swap(x,y);
        max=std::max(max,t.query(1,2,dfn[0],dfn[top[x]],dfn[x]));
        x=par[top[x]];
    }
    if(x==y) return max;
    if(dep[x]<dep[y]) std::swap(x,y);
    max=std::max(max,t.query(1,2,dfn[0],dfn[y]+1,dfn[x]));
    return max;
}
inline void mark(int x,int y,const int &w,const int &tag) {
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]]) std::swap(x,y);
        t.mark(1,2,dfn[0],dfn[top[x]],dfn[x],w,tag);
        x=par[top[x]];
    }
    if(x==y) return;
    if(dep[x]<dep[y]) std::swap(x,y);
    t.mark(1,2,dfn[0],dfn[y]+1,dfn[x],w,tag);
}
int main() {
    const int n=getint(),m=getint();
    for(register int i=0;i<m;i++) {
        const int u=getint(),v=getint(),w=getint();
        edge[i]={u,v,w,i};
    }
    std::sort(&edge[0],&edge[m]);
    s.reset(n);
    for(register int i=0;i<m;i++) {
        const int &u=edge[i].u,&v=edge[i].v,&w=edge[i].w,&id=edge[i].id;
        if(!s.same(u,v)) {
            vis[i]=true;
            add_edge(u,v,w,id);
            s.merge(u,v);
        }
    }
    dfs1(1,0);
    dfs2(1,0,0);
    t.build(1,2,n);
    for(register int i=0;i<m;i++) {
        if(vis[i]) continue;
        const int &u=edge[i].u,&v=edge[i].v,&w=edge[i].w,&id=edge[i].id;
        const int max=get_max(u,v);
        if(w>max) type[id]=2;
        if(w==max) {
            type[id]=1;
            mark(u,v,w,1);
        }
    }
    t.stat(1,2,n);
    for(register int i=0;i<m;i++) {
        if(type[i]==0) puts("any");
        if(type[i]==1) puts("at least one");
        if(type[i]==2) puts("none");
    }
    return 0;
}