POJ 1679 次小生成树 题解

The Unique MST

Time Limit: 1000MS Memory Limit: 10000K
Total Submissions: 29722 Accepted: 10632

Description

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!

Source

POJ Monthly–2004.06.27 srbga@POJ

【解题报告】
题目大意：给出一个图，问最小生成树是否唯一。
思路，很明显，这是次小生成树的存在问题。我的方法是两边prim，第一遍找到图中的最小生成树，把他的边记录下来。然后再执行 删边->prim->补边的操作。代码的可读性应该还是可以，所以说就不详细地讲解了。
（调了好久，最后发现是变量名用混了。。。）

代码如下：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define inf 0x7fffffff

int map[505][505],dis[505],dise[505];//dise[]是前驱 
int t,n,m,u,v,w;
bool uni;
int mst;//最小生成树的大小 
struct Edge//记录最小生成树的边 
{
    int u,v,w;
}edge[505];

void prim()
{
    uni=true;
    mst=0;
    int k=0;
    int now=1;
    int min_node;
    int min_edge;
    for(int i=1;i<=n;i++) dis[i]=inf; 
    for(int i=1;i<n;i++)//第一遍prim求出最小生成树 
    {
        dis[now]=-1; 
        min_edge=inf;
        for(int j=1;j<=n;j++)
        {
            if(now!=j&&dis[j]>=0)
            {
                if(map[now][j]<dis[j])
                {
                    dis[j]=map[now][j];
                    dise[j]=now;//记录前驱 
                }
                if(dis[j]<=min_edge)
                {
                    min_edge=dis[j];
                    min_node=j;
                }
            }
        }
        edge[i].u=min_node;
        edge[i].v=dise[min_node];
        edge[i].w=map[edge[i].u][edge[i].v];//记录边 
        now=min_node;
        mst+=min_edge;
    }
    for(int k=1;k<n;k++)//第二遍prim 
    {
        int sec_mst=0;
        bool flag=1;
        map[edge[k].u][edge[k].v]=map[edge[k].v][edge[k].u]=inf;//删边 
        if(k>1)
        map[edge[k-1].u][edge[k-1].v]=map[edge[k-1].v][edge[k-1].u]=edge[k-1].w;//恢复边 
        for(int i=1;i<=n;i++) dis[i]=inf; 
        for(int i=1;i<n;i++)
        {
            dis[now]=-1;
            min_edge=inf;
            for(int j=1;j<=n;j++)
            {
                if(now!=j&&dis[j]>=0)
                {
                    dis[j]=min(dis[j],map[now][j]);
                    if(dis[j]<=min_edge)
                    {
                        min_edge=dis[j];
                        min_node=j;
                    }
                }
            }
            if(min_edge==inf)//要记得判断是否存在次小生成树 
            {
                flag=0;
                break;
            }
            now=min_node;
            sec_mst+=min_edge;
        }
        if(flag&&sec_mst==mst)
        {
            uni=false;
            return;
        }
    }
}
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        map[i][j]=inf;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            map[u][v]=map[v][u]=w;
        }
        prim();
        if(!uni) printf("Not Unique!\n");
        else printf("%d\n",mst);
    }
    return 0;
}