算法训练 - 最小生成树

这是我做 kuangbin带你飞专题训练的第四个专题，对应的是 kuangbin带你飞专题六，这个专题是最小生成树专题，包含14道题目。

给定一个无向图，如果它的某个子图中任意两个顶点都互相连通并且是一棵树，那么这棵树就叫做生成树(Spanning Tree)。如果边上有权值，那么使边权和最小的生成树叫做最小生成树(Minimum Spanning Tree)。

常见的求解最小生成树的算法有 Prim算法和 Kruskal算法。很显然，生成树是否存在和图是否连通是等价的，因此我们假定图是连通的。

---

---

Prim算法

Prim算法和 Dijkstral算法很相似，都是从某一个顶点开始，不断添加边的算法。

首先我们假定有一颗只包含一个顶点 v 的树 T，然后贪心地选取 T 和图中不属于 T 的顶点集合 X 之间相连的最小权值的边，并且把它加到 T 中。不断进行这个操作，最后就可以得到一颗最小生成树。

实现上述算法有一个要点，就是如何找到与 T 相连的最小权值的边，可以用一个数组 mincost 来存储 X 中的顶点 u 和 T 中顶点 v 之间的最小距离，最多循环 V(顶点总数)次，就可以找到与 T 相连的最小权值边，这样做的时间复杂度为 $O(V^2)$， 如果用优先队列的话，每次只需要从队首去取相应的顶点即可，时间复杂度被优化至 O(E·log(V))。

下面是 Prim算法的代码模板

int cost[MAX_V][MAXV], mincost[MAX_V] ; // 邻接矩阵 cost 和记录与 T 之间距离的数组 mincost
bool used[MAX_V];
int V;


int prim()
{
    for (int i = 0;i < V;i++)
    {
        mincost[i] = cost[0][i];
        used[i] = false;
    }
    int ans = 0;
    while (true)
    {
        int v = -1;
        for (int u = 0;u < V;u++)
            if (!used[u] && (v==-1 || mincost[v]>mincost[u]))
                v = u;
        if (v==-1)
            break;
        used[v] = true;
        ans += mincost[v];
        for (int u = 0;u < V;u++)
            mincost[u] = min(mincost[u], cost[v][u]);
    }
    return ans;
}

Kruskal算法

Kruskal 算法按照边的权值的顺序从小到大依次检查一遍，如果不产生环（重边也算），就把当前这条边加入到最小生成树中。

Kruskal 算法实现中有一个要点是如何判断是否产生环。假设现在要把连接顶点 v 和顶点 u 的边 e 加入到生成树中，如果加入之前 u 和 v 不再同一个连通分量中，那么加入 e 也不会产生环。反之，如果 u 和 v 在同一个连通分量中，加入 e 就一定会产生环。可以用并查集来判断两个顶点是否在同一个连通分量中。Kruskal 算法在边的排序上最为费时，算法的时间复杂度是 O(E·log(V))。

如果无向图不是连通的，那么最后就无法构造出最小生成树，可以在 Kruskal算法跑过一遍之后，检查所有顶点被包括在几个连通分量中，当且仅当所有顶点都属于同一个连通分量时，最小生成树被构造成功。

以下是 Kruskal算法的代码模板：

struct edge{
    int from, to, cost;
}es[MAX_E];
bool cmp(const edge &a, const edge &b)
{
    return (a.cost < b.cost);
}
int V, E;

int kruskal()
{
    init_union_find(V);                      // 初始化并查集
    sort(es, es+E, cmp);
    int ans = 0, runs = 0;
    for (int i = 0;i < E;i++)
    {
        if (runs >= V-1)
            break;
        edge e = es[i];
        if (!same(e.from, e.to))
        {
            unite(e.from, e.to);
            ans += e.cost;
        }
    }
    return e.cost;
}

经典例题

POJ-2349 Arctic Network

解题思路： 一开始我的思路是将最长的前 S-1 条边的 D 值更改为 0 ，然后再求最小生成树。但是有的时候最长的边（而且大多数时候是这样）并不会被纳入最小生成树中。所以正确的思应该是先求最小生成树，被纳入其中的最长的 S-1 条边即是应该用卫星通信的村庄。所以最后的答案应该是倒数第 S-2 条边

#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

int const maxv = 510, maxe = 250010;

int N, S, P;

struct edge{
    int from, to;
    double cost;
}es[maxe];
int ei;

bool cmp(const edge &a, const edge &b)
{
    return (a.cost<b.cost);
}

struct node{
    double x, y;
}otpt[maxv];

// 并查集
int par[maxv], rankk[maxv];

void init_union_find(int n)
{
    for (int i = 0;i < n;i++)
    {
        par[i] = i;
        rankk[i] = 0;
    }
}

int find_node(int x)
{
    if (x == par[x])
        return x;
    return par[x] = find_node(par[x]);
}

void unite(int x, int y)
{
    x = find_node(x);
    y = find_node(y);

    if (x != y)
    {
        if (rankk[x] < rankk[y])
            par[x] = y;
        else
        {
            par[y] = x;
            if (rankk[x] == rankk[y])
                rankk[x] += 1;
        }
    }
}

bool same(int x, int y)
{
    return (find_node(x) == find_node(y));
}

void init()
{
    ei = 0;
    for (int i = 0;i < P;i++)
    {
        int x1 = otpt[i].x;
        int y1 = otpt[i].y;
        for (int j = i+1;j < P;j++)
        {
            int x2 = otpt[j].x;
            int y2 = otpt[j].y;
            es[ei].cost = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
            es[ei].from = i;
            es[ei].to = j;
            ei += 1;
        }
    }
}

double kruskal()
{
    sort(es, es+ei, cmp);
    init_union_find(P);
    double se[P];
    int pi = 0;
    for (int i = 0;i < ei;i++)
    {
        edge e = es[i];
        if (!same(e.from, e.to))
        {
            unite(e.from, e.to);
            se[pi++] = e.cost;
        }
    }
    return se[P-S-1];
}

int main()
{
    scanf("%d", &N);
    for (int i = 0;i < N;i++)
    {
        scanf("%d%d", &S, &P);
        for (int j = 0;j < P;j++)
            scanf("%lf%lf", &otpt[j].x, &otpt[j].y);
        init();
        printf("%.2f\n", kruskal());
    }

    return 0;
}

POJ-1679 The Unique MST

解题思路： 这道题属实费了一番周折，一开始我想的是把所有的重边找出来，然后去掉重边，看最小生成树是否唯一，我觉得这个想法可行，但是我不知为什么 WA 了，后来我又想把所有的边都去掉一次，看看最小生成树是否唯一，但是 TLE 了，后来从网上看到一种方法，把最小生成树中的边依次去掉，然后跑 kruskal 算法看是否仍存在最小生成树，这才 AC

#include <cstdio>
#include <algorithm>


using namespace std;

int const maxn = 110, maxe = 10010;

int N, M;
int mi, mst[maxe];

struct edge{
    int from, to;
    double cost;
}es[maxe];
int ei;
bool cmp(const edge &a, const edge &b)
{
    return (a.cost<b.cost);
}

// 并查集
int par[maxn], rankk[maxn];

void init_union_find()
{
    for (int i = 1;i <= maxn;i++)
    {
        par[i] = i;
        rankk[i] = 0;
    }
}

int find_node(int x)
{
    if (x == par[x])
        return x;
    return par[x] = find_node(par[x]);
}

void unite(int x, int y)
{
    x = find_node(x);
    y = find_node(y);

    if (x != y)
    {
        if (rankk[x] < rankk[y])
            par[x] = y;
        else
        {
            par[y] = x;
            if (rankk[x] == rankk[y])
                rankk[x] += 1;
        }
    }
}

bool same(int x, int y)
{
    return (find_node(x) == find_node(y));
}

int kruskal(int i)
{
    init_union_find();
    int ans = 0;
    for (int k = 0;k < ei;k++)
    {
        if (k == i)
            continue;
        edge e = es[k];
        if (!same(e.from, e.to))
        {
            unite(e.from, e.to);
            if(i == -1)   mst[mi++] = k;
            ans += e.cost;
        }
    }
    return ans;
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d%d", &N, &M);
        int u, v, c;
        ei = 0;
        for (int i = 0;i < M;i++)
        {
            scanf("%d%d%d", &u, &v, &c);
            es[ei].from = u;
            es[ei].to = v;
            es[ei++].cost = c;
        }

        sort(es, es+ei, cmp);
        mi = 0;
        int ans = kruskal(-1);
        bool flag = true;
        for (int i = 1;i < mi;i++)
        {
            int tmp = kruskal(mst[i]);
            if (tmp == ans)
            {
                flag = false;
                break;
            }
        }
        if (flag)
            printf("%d\n", ans);
        else
            printf("Not Unique!\n");
    }
    return 0;
}