次小生成树问题探讨

        为什么写这个呢？因为那天听到了这个词，属于MST的扩展……最小K度树有空研究。

一.理论准备

        需要读者事先懂得prime算法，不太了解的请看博主这一篇http://www.cnblogs.com/hxsyl/p/3286956.html，也需要读者对DP了解一些。

        先看一个结论：次小生成树可由最小生成树换一条边得到，笔者认为很有必要搞清楚这一点，，否则对算法理解不够深入。

         证明:咱换种方式去看待这个结论(一个生成树可以通过换边得到另一个生成树)，T是某一棵最小生成树，T0是任一棵异于T的生成树，通过变换T0 --> T1 --> T2 --> ... --> Tn (T)  变成最小生成树。所谓的变换是，每次把Ti中的某条边换成T中的一条边, 而且树T(i+1)的权小于等于Ti的权。

         看下面的具体步骤(一定要理解透彻)。
         step 1. 在Ti中任取一条不在T中的边uv.
         step 2. 把边uv去掉，就剩下两个连通分量A和B，在T中，必有唯一的边u'v' 连结A和B。这是为什么呢？因为生成树中任意两点间只有一条路径(下面也要用这个)，且必有一条。
         step 3. 显然u'v'的权比uv小 (prime算法贪心的，否则,uv就应该在T中)，把u'v'替换uv即得树T(i+1)。
         特别地：取T0为任一棵次小生成树，T(n-1) 也就是次小生成树且跟T差一条边， 结论得证。

         下面看具体算法。

         step 1.  先用prim求出最小生成树T，在prim的同时，用一个矩阵maxd[u][v] 记录 在T中连结任意两点u,v的唯一的路中权值最大的那条边的权值.(有些拗口)，这是很容易做到的，因为prim是每次增加一个结点s, 在此需要保存节点和其父节点，采用DP，则最大权值要么是新加入的边，要么是父节点到起始点的采用DP算出来的距离，如下：

//u是刚加入的点，不过还没进入节点数组，v是已经存在的点

//min是按prime新加入那条边

maxd[v][u] = maxd[u][v] = max{min，maxd[father[u]][v]}

        该步骤用时 O(V^2)，就是prime算法的耗时。

        step 2.  枚举所有不在T中的边uv, 加入边uv则必然替换权为maxd[u][v]的边，这样才能保证次小。

二.算法实现

            以POJ1679为例，判断最小生成树是否唯一(不唯一可能是重边，不过一般在做题里不可能，否则没法建图，另外就是一般情况了，看下图)。

        下面这三个图都是MST，权值161。

        只要最小生成树和次小生成树权值和一样就唯一。因此得出如下算法，首先计算出最小生成树T，然后对最小生成树上任意不相邻的两个点 uv添加最小生成树以外的存在的边形成环，然后寻找u与v之间最小生成树上最长的边删去，计算map[i][j]与 maxd[i][j差值，求出最小的来，如果是0，就说明MST和次小生成树一样。

//顶点数100，看成了1000，一个MLE，改了立马AC，嘿嘿

//这道题目，AC率很低

import java.util.Scanner;

public class POJ1679 {

  static int maxn = 105;

  static int[][] map = new int[maxn][maxn];

  static int[][] maxd = new int[maxn][maxn];

  static int[] father = new int[maxn];

  static int[] dist = new int[maxn];

  static boolean[] vis = new boolean[maxn];

  static int n,m;

  

  public static void main(String[] args) {

    

    Scanner sc= new Scanner(System.in);

    int num = sc.nextInt();

    int u,v,w;

    while(num-->0) {

      n = sc.nextInt();

      m = sc.nextInt();

      for(int i=1; i<=n; i++) {

        for(int j=1; j<=n; j++) {

          if(i==j) {

            map[i][j] = 0;

          }else {

            map[i][j] = 0x3f3f3f3f;

          }

          maxd[i][j] = -1;

        }

      }

      for(int i=0; i<m; i++) {

        u = sc.nextInt();

        v = sc.nextInt();

        w = sc.nextInt();

        map[u][v] = w;

        map[v][u] = w;

      }

      int ans = prime();

      int min = 0x3f3f3f3f;

      for(int i=1; i<=n; i++) {

        for(int j=1; j<=n; j++) {

          boolean tag = i!=j&&map[i][j]!=0x3f3f3f3f

              &&father[i]!=j&&father[j]!=i;

          if(tag) {

            if(min>map[i][j]-maxd[i][j]) {

              min = map[i][j]-maxd[i][j];

            }

          }

        }

      }

      if(0==min) {

        System.out.println("Not Unique!");

      }else {

        System.out.println(ans);

      }

    }

  }

  private static int prime() {

    

    int ans = 0;

    for(int i=1; i<=n; i++) {

      dist[i] = map[1][i];

      father[i] = 1;

      vis[i] = false;

    }

    vis[1] = true;

    //存放MST节点

    int stack[] = new int[n+1];

    int top = 0;

    stack[top++] = 1;

    for(int i=1; i<n; i++) {

      

      int next = 1;

      int min = 0x3f3f3f3f;

      for(int j=1; j<=n; j++) {

        if(!vis[j]&&min>dist[j]) {

          next = j;

          min = dist[j];

        }

      }

      vis[next] = true;

      ans += min;

      

      //dp

      for(int k=0; k<top; k++) {

        maxd[next][stack[k]] = maxd[stack[k]][next]

            = Math.max(min,maxd[father[next]][stack[k]]);

            

      }

      stack[top++] = next;

      for(int t=1; t<=n; t++) {

        if(!vis[t]&&dist[t]>map[next][t]) {

          dist[t] = map[next][t];

          father[t] = next;

        }

      }

    }

    return ans;

  }

}

        接下来该看数据挖掘十大算法了。