CF160D

题意：给你一个图，判断每条边是否在最小生成树MST上，不在输出none，如果在所有MST上就输出any,在某些MST上输出at least one；

分析：首先必须知道在最小生成树上的边的权值一定是等于任意最小生成树上的某条边的权值；那么我们按边的权值排序，每次同时加入权值相等的边

如果加入这条边之后形成loop那么这条边肯定不是最小生成树上的边，因为在此次加边之前，图上边的权值肯定是小于此次加入的边的权值的，如果加入这条边之后形成环，那么肯定不是MST上的边；加完边之后，如果这条边是bridge，那么这条边肯定是any，因为这条边是连接两个连通块的最小唯一边，如果边在剩下的边肯定在某些MST上；

注意：每一个阶段加完边之后要，要求出此阶段的联通情况，然后一个联通快缩点，然后在继续，这样每条边最多被经历一次，时间是O(m);

 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<iostream>
 #include<algorithm>
 #include<cmath>
 #include<vector>
 #include<set>
 #include<stack>
 using namespace std;
 const int N = +;
 struct node{
     int v,id;
     node(){}
     node(int v,int id):v(v),id(id){}
 };
 vector<node> G[N];
 int pre[N], low[N], eccno[N], dfs_clock, ecc_cnt;
 stack<int> SK;
 int an[N];
 int num;
 int vis[N];
 void dfs(int u,int fa) {
     pre[u] = low[u] = ++dfs_clock;
     int sz = G[u].size();
     bool first = true;
     for (int i =  ;i < sz; i++) {
         int v = G[u][i].v;
         if (v == fa && first)  {
                 first = false;
             continue;
         }
         if (pre[v] == ) {
             dfs(v,u);
             low[u] = min(low[u], low[v]);
             if (low[v] > pre[u]) an[G[u][i].id] = ;
         }else {
             low[u] = min(low[u],pre[v]);
         }
     }

 }

 int n,m;
 struct edge{
     int u,v,w,id;
     edge(){}
     edge(int u,int v,int w, int id):u(u),v(v),w(w),id(id){}
     bool operator < (const edge &p) const{
         return w < p.w;
     }
 };
 vector<edge> Eg;
 int p[N];
 int find(int x) {
     return p[x] == x ? x : p[x] = find(p[x]);
 }
 int mark[N];
 void build_graph(){
      sort(Eg.begin(),Eg.end());
      for (int i = ; i <= n; i++) p[i] = i;
      memset(mark,,sizeof(mark));
      for (int i = ; i < Eg.size(); i++) {
         int j = i;
         for (; j < Eg.size() && Eg[j].w == Eg[j+].w; j++);
           for (int k = i; k <= j; k++) {
             int u = Eg[k].u, v = Eg[k].v, w = Eg[k].w;
             int x = find(u), y = find(v);
             if (x != y) {
                 G[x].push_back(node(y,Eg[k].id));
                 G[y].push_back(node(x,Eg[k].id));
                 an[Eg[k].id] = ;
                 pre[x] = pre[y] = ;
                 mark[k] = x;
             }
         }
         dfs_clock = ;
         for (int k = i; k <= j; k++) {
             if (mark[k] && pre[mark[k]] == ) dfs(mark[k],-);
         }
         for (int k = i; k <= j; k++) {
             int u = Eg[k].u, v = Eg[k].v, w = Eg[k].w;
             int x = find(u), y = find(v);
             if (x != y) {
                 p[x] = y;
                 G[x].clear(); G[y].clear();
             }
         }
         i = j;
      }

 }
 void solve(){
     memset(an,,sizeof(an));
     build_graph();
     for (int i = ; i < m; i++) {
         if (an[i] == ) printf("none\n");
         else if (an[i] == ) printf("at least one\n");
         else if (an[i] == ) printf("any\n");
     }
 }
 int main(){
     while (~scanf("%d%d",&n,&m)) {
         Eg.clear();
         for (int i = ; i < m; i++) {
             int u,v,w;
             scanf("%d%d%d",&u,&v,&w);
             Eg.push_back(edge(u,v,w,i));
         }
         solve();
     }

     return ;
 }