关于生成树

　　基本概念：

　　树：如果一个无向连通图G中不存在回路，则称图G是一颗树。

　　生成树：无向连通图G的一个子图如果是一颗包含了G中所有顶点的树，则称它为图G的生成树。

注意：生成树是图G的极小连通子图，表示在若在图中任添加一条边都将形成一个回路，同样的，若任意去掉一条边都将使图不在连通。

　　如果在边中加上权值，那么权值最小的生成树即为最小生成树，权值最大的生成树为最大生成树。

　　

　　最小生成树算法：

　　由生成树的定义不难知道，BFS或DFS不重复的遍历结果就是一个生成树。通常情况下，我们都是要求最小生成树的。求最小生成树的算法有三种：Kruskal算法，Boruvka算法，Prime算法。常用的是Kruskal算法和Prime算法。

　　Kruskal算法核心思想：作用与边，每次选取当前可用的最小权值的边。

Kruskal算法有两个注意的地方：① 当前可用，即若某边的权值最小，但它关联的两个顶点本省已经在同一个集合里了也是不可选的。

　　　　　　　　　　　　　　 ② 最小权值，这个是必须的，不多说。

　　Prime算法核心思想：作用与顶点，通过选择当前可用的最小权值的边把其他顶点加入到生成树当中。

算法过程：

1.将一个图的顶点分为两部分，一部分是最小生成树中的结点（A集合），另一部分是未处理的结点（B集合）。

2.首先选择一个结点，将这个结点加入A中，然后，对集合A中的顶点遍历，找出A中顶点关联的边权值最小的那个B中的结点（设为v），将此顶点从B中删除，加入集合A中。

3.重复步骤2，直到B集合中的结点为空，结束此过程。

4.A集合中的结点就是由Prime算法得到的最小生成树的结点，依照步骤2的结点连接这些顶点，得到的就是这个图的最小生成树。

代码：

int mat[N][N];
int lowcost[N];
int pre[N];
int n, m;
bool used[N];

int Prime(int s)
{
    for(int i=1; i<=n; i++)
        lowcost[i] = mat[s][i], pre[i]=s;
    used[s] = true;
    lowcost[s] = 0;
    int mst=0, cnt=0;
    for(int i=1; i<n; i++)
    {
        int tmp=INF, k;
        for(int j=1; j<=n; j++)
            if(!used[j] && lowcost[j]<tmp)
                tmp = lowcost[k=j];
        if(tmp==INF) break;
        used[k] = true;
        // 输出最小生成树中边
        printf("%d %d %d
", k, pre[k], lowcost[k]);
        mst += tmp;
        if(++cnt ==n-1) break;
        for(int j=1; j<=n; j++)
            if(!used[j] && mat[k][j] < lowcost[j])
                lowcost[j] = mat[k][j], pre[j]=k;
    }
    return mst;
}

　　最大生成树：

　　从最小生成的求法中，我们知道，关键都是每次选取权值最小的，那么最大生成树算法只需每次在Kruskal和Prime中选取最大的即可。

　　还可以这样，记录边权的时候，每次乘一个-1，变为负权的图，然后用Prime求最小生成树，再把结果×-1，也可得到最大生成树的权值。

　　次小生成树算法：

　　次小生成树：所谓的次小生成树，是指在边集与某一最小生成树的边集不完全相同的其它生成树中值最小的那个。因此在数值上，最小生成树可能会等于次小生成树，这种情况也可以看做最小生成数。

　　思路：最直观的解法是，首先求出最小生成树，并且记录最小生成树中的边，然后再枚举删除最小生成树的边并同时求最小生成树。

以POJ1679为例，Kruskal求次小生成树代码如下：

#include<cstdio>
#include<cstring>
#include<algorithm>
#define _Clr(x, y) memset(x, y, sizeof(x))
#define INF 0x3f3f3f3f
#define N 110
using namespace std;

struct Edge
{
    int a, b;
    int c;
    bool operator < (const Edge &a) const
    {
        return c < a.c;
    }
}edge[N*N];
int bleg[N], n, m;
int mst_edge[N];

int find(int x)
{
    int y = x;
    while(y != bleg[y])
        y = bleg[y];
    while(x != bleg[x])
    {
        int px = bleg[x];
        bleg[x] = y;
        x = px;
    }
    return y;
}

void Union(int a, int b)
{
    int pa=find(a), pb=find(b);
    if(pa != pb)
        bleg[pa] = pb;
}

inline void Init()
{
    for(int i=0; i<=n; i++)
        bleg[i] = i;
}

void Kruskal()
{
    int mst_1=0;
    Init();
    _Clr(mst_edge, 0);
    sort(edge, edge+m);
    int k=0;
    for(int i=0; i<m && k<n-1; i++)
    {
        int a=find(edge[i].a);
        int b=find(edge[i].b);
        if(a != b)
        {
            mst_edge[k] = i;
            Union(a, b);
            mst_1 += edge[i].c;
            k++;
        }
    }
    // 枚举删除最小生成树中所有边求MST
    for(int i=0; i<n-1; i++)
    {
        int mst_2=0, k=0;
        Init();
        for(int j=0; j<m && k<n-1; j++)
        {
            if(mst_edge[i] == j) continue;
            int a=find(edge[j].a);
            int b=find(edge[j].b);
            if(a != b)
            {
                Union(a, b);
                mst_2 += edge[j].c;
                k++;
            }
        }
        if(mst_1==mst_2 && k==n-1)
        {
            puts("Not Unique!");
            return;
        }
    }
    printf("%d
", mst_1);
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &n, &m);
        for(int i=0; i<m; i++)
            scanf("%d%d%d", &edge[i].a, &edge[i].b, &edge[i].c);
        Kruskal();
    }
    return 0;
}