最小生成树

最小生成树

给你一个n个点m条边的带权无向图，请你找出能够连接所有边且权重最小的边，如果不能则指明。

最小生成树是一道经典的图论算法题，主要的求解方法有两个，一个是Kruskal算法，另一个是prim算法。时间复杂度分别为$O(ElogE)$,$O(ElogV)\text{(堆优化)}$。

这两种算法一个用了并查集，一个用了优先队列，共同点是都用到了贪心思想。最终得到的边的数量一定是$V-1$条。

Kruskal算法

Kruskal算法使用了并查集，通过维护多个小的集合，最后合并成一个大的集合实现。思路是从权重最小的边开始，每次查看当前边的两个点是否在一个集合中，如果在，那么这条边就不是我们要找的边，因为之前一定已经将一条权重更小的边加入使得两个点在一个集合中了；如果不在，说明这两个点之间还没有一条边被加入进来，我们必须加入这条边使集合合并。

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 1e5 + 10, M = 2e5 + 10, INF = 0x3f3f3f3f;
int n, m;
int fa[N];

int find(int x) {
    if (fa[x] == x) return x;
    return fa[x] = find(fa[x]);
}

struct Edge {
    int u, v, w;
    bool operator < (const Edge& that) const {
        return w < that.w;
    }
} edges[M];

int kruskal() {
    sort(edges, edges + m);
    for (int i = 0; i <= n; i ++ ) fa[i] = i;
    
    int cnt = 0, ret = 0;
    for (int i = 0; i < m; i ++ ) {
        int u = edges[i].u, v = edges[i].v, w = edges[i].w;
        u = find(u), v = find(v);
        if (u != v) { // 这里就是加入边的过程，也就是并查集的合并过程，这里计算的是所有边的权重，完全可以改成任何其它的要求。
            fa[u] = v;
            ret += w;
            cnt ++ ;
        }
    }
    return cnt == n - 1 ? ret : INF; // 如果没有n - 1条边，说明有的点是孤立的。
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i ++ ) {
        int u, v, w;
        scanf ("%d%d%d", &u, &v, &w);
        edges[i] = {u, v, w};
    }
    int ans = kruskal();
    if (ans == INF) puts("impossible");
    else printf("%d\n", ans);
    return 0;
}

Prim算法

Prim算法使用优先队列来完成。思路是从任意一个点开始，将与它连接的所有边放入队列中，拿出权重最小的边。

typedef pair<int, int> P;
struct Edge
{
    int to, cost;
};
vector<Edge>edge[maxV];
int V;
int mincost[maxV];
bool vis[maxV];
void prim()
{
    priority_queue<P, vector<P>, greater<P> >que;
    fill(mincost, mincost + V, inf);
    memset(vis, false, sizeof(vis));
    int ans = 0;
    mincost[0] = 0;
    que.push(P(0, 0));
    while(!que.empty())
    {
        P p = que.top();
        que.pop();
        int v = p.second;
        vis[v] = true;
        if(mincost[v] < p.first)
            continue;
        for(int i = 0; i < edge[v].size(); i++)
        {
            Edge e = edge[v][i];
            if(!vis[e.to] && mincost[e.to] > e.cost)
            {
                ans += e.cost;
                if(mincost[e.to] != inf)
                    ans -= mincost[e.to];
                mincost[e.to] = e.cost;
                que.push(P(mincost[e.to], e.to));
            }
        }
    }
    printf("%d\n", ans);
}