POJ 1679 判最小生成树的不唯一性 或 利用次小生成树求解

题目大意：

给定一个无向图，寻找它的最小生成树，如果仅有一种最小生成树，输出所有边的和，否则输出unique!

 

根据kruscal原理来说，每次不断取尽可能小的边不断添加入最小生成树中，那么可知如果所有边的长度都不相同，那么kruscal取得过程必然只有一种情况，由小到大

所以要是存在多种情况的最小生成树，那么必然是存在相同的边

初始将所有相同的边进行标记，生成第一次最小生成树后，不断去除其中带标记的边，然后再计算最小生成树，判断能否得到同样的答案，如果可以，说明不止一种情况

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 105
int fa[N] , same[N] , first[N] , k;
int rec[N] , amo;//rec[]记录MST中含有相同长度边的位置,amo记录其数量
struct Edge{
    int x,y,d,next,flag;
    bool same;
    bool operator<(const Edge &m) const{
        return d<m.d;
    }
}e[N*N];

int find_head(int x)
{
    while(fa[x]!=x) x=fa[x];
    return x;
}

bool Union(int x,int y)
{
    int fa_x = find_head(x);
    int fa_y = find_head(y);
    fa[fa_x] = fa_y;
    return fa_x == fa_y;
}

void add_edge(int x, int y , int d)
{
    e[k].x=x , e[k].y=y , e[k].d=d , e[k].flag=1 , e[k].next=first[x];
    e[k].same = false;
    first[x] = k++;
}

int cal_MST(int n , int flag)
{
    int ans = 0 , cnt=0;
    for(int i=1 ; i<=n ; i++) fa[i]=i;
    for(int i=0 ; i<k ; i++){
        if(e[i].flag==1){
            if(!Union(e[i].x , e[i].y)){
                ans+=e[i].d;
                if(e[i].same && flag){
                    rec[amo++] = i;
                }
                cnt++;
                if(cnt == n-1) break;
            }
        }
    }
    return ans;
}

int main()
{
    int T;
    scanf("%d" , &T);
    while(T--)
    {
        int n , m , x , y , d;
        scanf("%d%d" , &n , &m);
        k=0;
        memset(first , -1 , sizeof(first));
        for(int i=0 ; i<m ; i++){
            scanf("%d%d%d" , &x , &y , &d);
            add_edge(x , y , d);
        }

        sort(e , e+k);
        //对存在相同边的边进行标记
        for(int i=1 ; i<k ; i++)
            if(e[i].d == e[i-1].d) e[i].same=e[i-1].same=true;
        amo = 0;
        int ans = cal_MST(n , 1);
        bool is_unique = true;
        for(int i=0 ; i<amo ; i++){
            e[rec[i]].flag = 0;
            int t=cal_MST(n , 0);
            if(t == ans){
                is_unique=false;
                break;
            }
            e[rec[i]].flag = 1;
        }
        if(is_unique) printf("%d\n" , ans);
        else puts("Not Unique!");
    }
    return 0;
}

上面那个明显复杂度比较高

我们可以求解出次小生成树的值与最小生成树的值进行比较判断是否唯一

先求出最小生成树，用二维数组mx[][]记录最小生成树上两个点之间路径上最长边的长度

然后找到每一条不属于最小生成树的边u,v ，这样可以与原最小生成树中u->v的路径形成一个环，那么最后需要在环中删去一条最长边，那么只要不断得到这个差值的最小值

用最小生成树的值减去他就可以了

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define N 105
const int INF = 0x3f3f3f3f;
int mx[N][N] , w[N][N];
int n , m;
int d[N] , connect[N];
bool vis[N][N] , in[N];

int prim()
{
    int ret = 0;
    memset(vis , 0 , sizeof(vis));
    memset(connect , 0 , sizeof(connect));
    memset(in , 0 , sizeof(in));
    memset(mx , 0 , sizeof(mx));
    d[1] = INF , in[1] = true;
    for(int i=2 ; i<=n ; i++)
        if(w[1][i]>=0){
            d[i] = w[1][i];
            connect[i] = 1;
        }
        else d[i] = INF;

    for(int i=1 ; i<n ; i++){
        int minn = INF , index = 0;
        for(int j=1 ; j<=n ; j++){
            if(in[j]) continue;
            if(d[j]<minn) minn=d[j] , index=j;
        }
        int u = connect[index];
        d[index] = INF , vis[index][u] = vis[u][index] = true;
        mx[index][u] = mx[u][index] = minn , in[index] = true , ret+=minn;
        for(int j=1 ; j<=n ; j++){
            if(in[j] || w[index][j]<0) continue;
            if(w[index][j]<d[j]) d[j] = w[index][j] , connect[j] = index;
        }
        for(int j=1 ; j<=n ; j++){
            if(!in[j]) continue;
            mx[j][index] = mx[index][j] = max(mx[index][j] , max(mx[index][u] , minn));
        }
    }
    return ret;
}

int sec_mst(int mst)
{
    int del = INF;
    for(int i=1 ; i<=n ; i++){
        for(int j=i+1 ; j<=n ; j++){
            if(!vis[i][j] && w[i][j]>=0){
                del = min(del , mx[i][j]-w[i][j]);
            }
        }
    }
    return mst-del;
}

int main()
{
  //  freopen("in.txt" , "r" , stdin);
    int T;
    scanf("%d" , &T);
    while(T--)
    {
        scanf("%d%d" , &n , &m);
        memset(w , -1 , sizeof(w));
        int u , v , wei;
        while(m--){
            scanf("%d%d%d" , &u , &v , &wei);
            w[u][v] = w[v][u] = wei;
        }
        int ret = prim();
        int sec = sec_mst(ret);
        if(ret == sec) puts("Not Unique!");
        else printf("%d\n" , ret);
    }
    return 0;
}