ACM/ICPC 之 判别MST唯一性-Kruskal解法(POJ1679)

判别MST是否唯一的例题。

---

POJ1679-The Unique MST

　

　　题意：给定图，求MST(最小生成树)是否唯一，唯一输出路径长，否则输出Not Unique!

　　题解：MST是否唯一取决于是否有两边权值相同(其中一条边在第一次求得的MST内，另一条在MST外)的情况。

　　　　　如果存在这样的边，则需要逐次删除MST内的该边，再次求MST，如果此次求得的MST路长与第一次MST相同，则确实存在不唯一的MST

　　　　　否则，一定不存在多条MST。

//Kruskal-判断MST是否唯一
//Time:0MS    Memory:868K
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;

#define MAX 101

struct Edge {
    int u, v;
    int w;
    bool used;    //First Used
    bool del;    //Kruskal是否不考虑此边
    friend bool operator < (Edge e1, Edge e2) { return e1.w < e2.w; }
}e[MAX*MAX];

int n, m;
bool first;    //是否第一次求MST
int fa[MAX];
int del[MAX*MAX], len;    //须逐次删除的边
int minroad;    //第一次MST结果

int Find(int x)
{
    return fa[x] < 0 ? x : fa[x] = Find(fa[x]);
}

void Union(int r1, int r2)
{
    r1 = Find(r1);
    r2 = Find(r2);
    int num = fa[r1] + fa[r2];
    if (fa[r1] < fa[r2])
    {
        fa[r2] = r1;
        fa[r1] = num;
    }
    else {
        fa[r1] = r2;
        fa[r2] = num;
    }
}

bool kruskal()
{
    memset(fa, -1, sizeof(fa));
    int num = 0;
    int mind = 0;
    for (int i = 0; i < m; i++)
    {
        if (e[i].del)    continue;
        if (Find(e[i].u) == Find(e[i].v))    continue;
        Union(e[i].u, e[i].v);
        if (first) {
            minroad += e[i].w;
            e[i].used = true;
        }
        mind += e[i].w;
        if (mind > minroad) return true;
        if (++num == n - 1) break;
    }
    
    return false;
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d", &n, &m);
        memset(e, 0, sizeof(e));
        for (int i = 0; i < m; i++)
            scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);

        len = 0;
        sort(e, e + m);
        for (int i = 0; i < m; i++)
            if (e[i].w == e[i + 1].w)
            {
                if(del[len-1] != i) del[len++] = i;
                del[len++] = i + 1;
            }
        
        minroad = 0;
        first = true;
        kruskal();
        first = false;

        bool unique = true;
        for (int i = 0; i < len; i++)
        {
            if (!e[del[i]].used) continue;    //使用过的才删除
            e[del[i]].del = true;    //删除
            if (!kruskal())
            {
                printf("Not Unique!
");
                unique = false; break;
            }
            e[del[i]].del = false;    //恢复
        }

        if (unique)
            printf("%d
", minroad);
    }



    return 0;
}