POJ-1679 The Unique MST

判断最小生成树路径唯一

POJ-1679 The Unique MST (poj.org)

思路

kruskal先跑一遍记录路径 然后依次删掉每条边判断新最小生成树与远最小生成树是否相等

复杂度O(nmlogm) ,待学习新方法

#include<iostream>
#include<algorithm>
using namespace std;
//最小生成树是否唯一
long long read(){
    long long ret=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-f;ch=getchar();}
    while(ch>='0'&&ch<='9') ret=ret*10+ch-'0',ch=getchar();
    return ret*f;
}
int f[100001];
int n,m,num,t,sum;
int F(int x){
    return x == f[x] ? x : f[x] = F(f[x]);
}
int vis[100001];
struct node{
    int u,v,w;
}a[100001];
void init(int n){
    for(int i = 1; i <= n; i++){
        f[i] = i;
    }
}
bool cmp(node a, node b){
    return a.w < b.w;
}
int main(){
    t = read();
    while(t--){
        n = read(); m = read();
        num = 0;
        sum = 0;
        init(n);
        for(int i = 1; i <= m; i++){
            a[i].u = read();
            a[i].v = read();
            a[i].w = read();
        }
        sort(a + 1, a + 1 + m, cmp);
        for(int i = 1; i <= m; i++){
            int x = F(a[i].u);
            int y = F(a[i].v);
            if(x != y){
                f[x] = y;
                vis[++num] = i;
                sum += a[i].w;
            }
        }
        int flag = 0;
        for(int i = 1; i <= num; i++){
            init(n);
            int sum2 = 0;
            int num2 = 0;
            for(int j = 1; j <= m; j++){
                if(j == vis[i])continue;
                int x = F(a[j].u);
                int y = F(a[j].v);
                if(x != y){
                    f[x] = y;
                    sum2 += a[j].w;
                    num2 ++;
                }
                if(num2 != num)continue;
                if(sum2 == sum){
                    flag = 1;
                    break;
                }
            }
            if(flag == 1)break;
            
        }
        if(flag == 1){
            puts("Not Unique!");
        }else {
            cout << sum << endl;
        }
    }
    return 0;
}

学到一种新方法

考虑最小生成树的唯一性。如果一条边 不在最小生成树的边集中，并且可以替换与其 权值相同、并且在最小生成树边集 的另一条边。那么，这个最小生成树就是不唯一的。

证明方法kruskal

对于已连接的边集E ,考虑下一条加入的边v,若存在另一条边v1，v1 > v || v1 < v时，v1都不可能是下一条加入的边。

所以只需要考虑当前边长度相同的边即可

由于使用了单调队列所以复杂度和kruskal相同

#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;
long long read(){
    long long ret=0,f=1;char ch=getchar();
    while(ch>'9'||ch<'0'){if(ch=='-')f=-f;ch=getchar();}
    while(ch>='0'&&ch<='9') ret=ret*10+ch-'0',ch=getchar();
    return ret*f;
}
int n,m,t;
int f[100001];
struct node{
    int u,v,w;
};
node a[100001];
int F(int x){
    return x == f[x] ? x : f[x] = F(f[x]);
}
bool cmp(node a, node b){
    return a.w < b.w;
}
int main(){
    t = read();
    while(t--){
        n = read(); m = read();
        for(int i = 1; i <= n; i++){
            f[i] = i;
        }
        for(int i = 1; i <= m; i++){
            a[i].u = read();
            a[i].v = read();
            a[i].w = read();
        }
        sort(a + 1, a + 1 + m, cmp);
        int sum1 = 0, sum2 = 0, num = 0, flag = 0,tail = 0, ans = 0;
        for(int i = 1; i <= m + 1; i++){
            if(i > tail){//tail记录最后长度相同的边的指针
                //sum2记录可以合并的长度相同的边数
                //sum1记录实际最小生成树中连接的边数
                //如果两个不相等说明有可以替换的边，则最小生成树不唯一
                if(sum1 != sum2){
                    flag = 1;
                    break;
                }
                sum1 = 0;
                sum2 = 0;
                for(int j = i; j <= m + 1; j++){
                    if(a[j].w != a[i].w){
                        tail = j - 1;
                        break;
                    }
                    if(F(a[j].u) != F(a[j].v)){
                        sum2++;
                    }
                }
            }
            if(i > m)break;
            int x = F(a[i].u);
            int y = F(a[i].v);
            if(x != y && num != n-1){
                f[x] = y;
                num ++;
                sum1++;
                ans += a[i].w;
            }
        }
        if(flag == 0){
            printf("%d\n",ans);
        }else{
            printf("Not Unique!\n");
        }
    }
}