poj 1679 The Unique MST (最小生成树是否唯一)

Given a connected undirected graph, tell if its minimum spanning tree is unique.

Definition 1 (Spanning Tree): Consider a connected, undirected graph G = (V, E). A spanning tree of G is a subgraph of G, say T = (V’, E’), with the following properties:
1. V’ = V.
2. T is connected and acyclic.

Definition 2 (Minimum Spanning Tree): Consider an edge-weighted, connected, undirected graph G = (V, E). The minimum spanning tree T = (V, E’) of G is the spanning tree that has the smallest total cost. The total cost of T means the sum of the weights on all the edges in E’.
Input
The first line contains a single integer t (1 <= t <= 20), the number of test cases. Each case represents a graph. It begins with a line containing two integers n and m (1 <= n <= 100), the number of nodes and edges. Each of the following m lines contains a triple (xi, yi, wi), indicating that xi and yi are connected by an edge with weight = wi. For any two nodes, there is at most one edge connecting them.
Output
For each input, if the MST is unique, print the total cost of it, or otherwise print the string ‘Not Unique!’.
Sample Input
2
3 3
1 2 1
2 3 2
3 1 3
4 4
1 2 2
2 3 2
3 4 2
4 1 2
Sample Output
3
Not Unique!

这个题真的是有点伤啊，没有给m的范围，我直接开到10000就过了，这个题的题意就是让你判断，给出的边，能构成的最下生成树是否唯一，就是只有这一种构图方法,使用其他的都会是最后的花费变大

思路就是先用Kruskra跑一遍，然后得到一个最小的花费dis_min，然后把使用的边全部存到一个数组如basic中，最后再把basic中的边逐个取消，就是不适用这条边，再用kruskra，如果结果等于dis_min,那么结果不止一个，如果没有就在最后输出dis_min,中间我犯了一个傻逼错误，把记录边的输出开成了点的最大范围，结果一直run，真的是，头皮发麻

代码如下：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;
const int MAX_V = 110;
const int MAX_E = 10100;
int t,V,E;
int pre[MAX_V];
struct Edge{
    int x,y,z;
};
struct Edge q[MAX_E];
int Find(int x){
    int r = x;
    while(pre[r] != r)
        r = pre[r];
    int i = x,j;
    while(i != r){
        j = pre[i];
        pre[i] = r;
        i = j;
    }
    return r;
}

bool add(int x,int y){
    int fx = Find(x),fy = Find(y);
    if(fx != fy){
        pre[fx] = fy;
        return true;
    }
    return false;
}

void init(){//并查集的初始化
    for(int i=1;i<=V;i++)
        pre[i] = i;
}

int Kruskal(int s_){//在不使用s_的最小生成树
    int res = 0,Count = 0;;
    for(int i=1;i<=E;i++){
        if(i != s_ && add(q[i].x,q[i].y)){
            res += q[i].z;
            Count++;
        }
        if(Count == V-1)    return res;
    }
    return -1;
}
bool cmp(Edge a,Edge b){
    return a.z < b.z;
}
int basic[MAX_V],top,dis_min;
int main(void){
    scanf("%d",&t);
    while(t--){
        scanf("%d %d",&V,&E);
        for(int i=1;i<=E;i++)
            scanf("%d %d %d",&q[i].x,&q[i].y,&q[i].z);
        init();
        top = 0;dis_min = 0;
        sort(q+1,q+1+E,cmp);
        for(int i=1;i<=E;i++){
            if(add(q[i].x,q[i].y)){
                basic[++top] = i;//记录使用的边
                dis_min += q[i].z;
            }
            if(top == V-1)  break;
        }
        bool isok = true;
        for(int i=1;i<=top;i++){//枚举使用过的边
            init();
            int dis = Kruskal(basic[i]);
            if(dis == -1)   break;//如果无法构成最小生成树，直接跳出
            if(dis == dis_min){
                isok = false;
                break;
            }
        }
        if(isok)    printf("%d\n",dis_min);
        else printf("Not Unique!\n");
    }

    return 0;
}