POJ 1679 The Unique MST

 

 

关于次小生成树的构造：

 

在求最小生成树时，用数组Max[i][j]来表示MST中i到j最大边权。

求完后，直接枚举所有不在MST中的边，把它加入到MST中构成一棵新的树，且该树有环，此环是由刚加入的边(i,j)造成的，所以可以通过删除Max[i][j]即可得到新的一颗树，且所有的该类树中必有一棵为次小生成树。

如图所示：

G,H不是MST上的边，通过加入边(G,H),得到一个环（B,H,G）,由于在计算最小生成树时已经计算出G,H之间最大边权为Max[G][H] = BH，所以通过删除BH即可得到一棵此时最小的生成树，然后更新答案即可。

实际上，我们知道MST的构造是具有贪心性质的，假如上图是一棵MST的话，那么必然有w(B,H) < w(G,H)。实际上w(B,H)是G->H的第二大边权，所以我们可以增加w(G,H)，然后删除w(B,H)得到的是权值和第二大的树，这时我们就可以通过枚举所有不在MST树中（!use[i][j]）的办法来生成次小生成树。

 

CODE：

 

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
using  namespace std;

const  int MAXN =  110;
const  int INF =  0x3f3f3f3f;
int N, M;
int w[MAXN][MAXN] ,d[MAXN];
bool vis[MAXN], use[MAXN][MAXN];
int cnt ,fa[MAXN], Max[MAXN][MAXN] ;

void init()
{
    cnt =  0;
    memset(use,  0,  sizeof(use));
    memset(vis,  0,  sizeof(vis));
    memset(w, INF,  sizeof(w));
    memset(Max,  0,  sizeof(Max));
}

void Prim( int src)
{
     for( int i =  1; i <= N; i++) d[i] = (i == src)?  0:INF;
     for( int i =  1; i <= N; i++) fa[i] = i;
     for( int i =  1; i <= N; i++)
    {
         int m = INF, x ;
         for( int y =  1; y <= N; y++)  if(!vis[y] && d[y] < m) m = d[x=y];
         for( int y =  1; y <= N; y++)  if(vis[y]) /* 这是算法的关键，记录下vis[y]到k的路径中权值最大的值，用于替换处理 */
        {
            Max[x][y] = Max[y][x] = max(Max[y][fa[x]], d[x]);     // 这里我出现了一个非常严重的错误，POJ竟然没报错！！
             // Max[x][y] = Max[y][x] = d[x]; 
        }
        vis[x] =  1;
        use[x][fa[x]] = use[fa[x]][x] =  1;  // 标记在MST树中 
        cnt += m;
         for( int y =  1; y <= N; y++)
        {
             if(!vis[y] && d[y] > w[x][y])
            {
                d[y] = w[x][y];
                fa[y] = x;  // 记录父亲节点 
             }
        }
    }
}

int smst()  // second MST
{
     int Min = INF;
     for( int i =  1; i <= N; i++)
    {
         for( int j = i+ 1; j <= N; j++)
        {
             if(w[i][j] != INF && !use[i][j])
            {
                 int res = cnt + w[i][j] - Max[i][j];
                Min = min(Min, res);
            }
        }
    }
     if(Min == cnt)  return  0;
     return  1;
}


int main()
{
     int T;
    scanf( " %d ", &T);
     while(T--)
    {
        init();
        scanf( " %d%d ", &N, &M);
         while(M--)
        {
             int u, v, cost;
            scanf( " %d%d%d ", &u, &v, &cost);
             if(w[u][v] > cost)  // 可能有重边 
            {
                w[u][v] = w[v][u] = cost;
            }
        }
        Prim( 1);
         if(smst())
        {
            printf( " %d\n ", cnt);
        }
         else printf( " Not Unique!\n ");
    }
     return  0;
}

 

 CODE：

 

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
using  namespace std;

const  int MAXN =  110;
const  int INF =  0x3f3f3f3f;
int n, m;
int w[MAXN][MAXN], d[MAXN];
bool vis[MAXN], use[MAXN][MAXN];
int cnt ,fa[MAXN], path[MAXN][MAXN];

void init()
{
    cnt =  0;
    memset(use,  0,  sizeof(use));
    memset(vis,  0,  sizeof(vis));
    memset(w, INF,  sizeof(w));
    memset(path,  0,  sizeof(path));
}

void Prim( int src)
{
     for( int i =  1; i <= n; i++) { d[i] = (i == src)? 0:INF; fa[i] = i; }
     for( int i =  1; i <= n; i++)
    {
         int x, m = INF;
         for( int y =  1; y <= n; y++)  if(!vis[y] && m > d[y]) m = d[x=y];
         for( int y =  1; y <= n; y++)  if(vis[y])  // 更新 
        {
            path[x][y] = path[y][x] = max(path[y][fa[x]], d[x]);
        }
        vis[x] =  1;
        use[x][fa[x]] = use[fa[x]][x] =  1;
        cnt += m;
         for( int y =  1; y <= n; y++)  if(d[y] > w[x][y])
        {
            d[y] = w[x][y];
            fa[y] = x;
        }
    }
}

int smst()
{
     int Min = INF, res;
     for( int i =  1; i <= n; i++)
    {
         for( int j = i+ 1; j <= n; j++)  if(w[i][j] != INF && !use[i][j])  // 枚举 
        {
            res = cnt + w[i][j] - path[i][j];
            Min = min(Min, res);
        }
    }
     if(Min == cnt)  return  0;
     return  1;
}


int main()
{
     int T;
    scanf( " %d ", &T);
     while(T--)
    {
        init();
        scanf( " %d%d ", &n, &m);
         while(m--)
        {
             int u, v, cost;
            scanf( " %d%d%d ", &u, &v, &cost);
             if(w[u][v] > cost)  // 可能有重边 
            {
                w[u][v] = w[v][u] = cost;
            }
        }
        Prim( 1);
         if(smst())
        {
            printf( " %d\n ", cnt);
        }
         else printf( " Not Unique!\n ");
    }
     return  0;
}