最小生成树

最新推荐文章于 2024-09-15 11:22:31 发布

LIHAORAN99

最新推荐文章于 2024-09-15 11:22:31 发布

阅读量534

点赞数 12

文章标签：图论算法 leetcode 数据结构 c++ 开发语言

本文链接：https://blog.csdn.net/weixin_45092290/article/details/141114846

版权

最小生成树（Minimum Spanning Tree, MST）是一种在加权无向图中找到一个子图，使得子图覆盖所有的顶点，且边的权重之和最小。这个子图应是连通的并且没有环，从而形成一棵树。最小生成树在网络设计、电路设计等领域有着广泛的应用。常用的最小生成树算法有以下几种：

1. 普里姆算法（Prim’s Algorithm）：

初始化：从图中的任意顶点开始构建最小生成树。
过程：在已经选取的顶点集合中，找到一条边，其一端是已经选取的顶点，另一端是未选取的顶点，并且这条边的权重最小。
更新：将这条边以及它的未选取端点加入到最小生成树中。
重复以上过程，直到所有的顶点都被选取。

#include <iostream>
#include <vector>
#include <queue>
#include <utility>

using namespace std;

typedef pair<int, int> pii;

const int MAXN = 1000;  // 最大顶点数
vector<pii> adj[MAXN];  // 邻接表
bool visited[MAXN];     // 访问标记

int prim(int n) {
    priority_queue<pii, vector<pii>, greater<pii>> pq;
    int total_cost = 0;
    pq.push({0, 0});  // 从顶点0开始

    while (!pq.empty()) {
        int cost = pq.top().first;
        int u = pq.top().second;
        pq.pop();

        if (visited[u]) {
            continue;
        }
        visited[u] = true;
        total_cost += cost;

        for (auto &edge : adj[u]) {
            int v = edge.first;
            int next_cost = edge.second;
            if (!visited[v]) {
                pq.push({next_cost, v});
            }
        }
    }

    return total_cost;  // 返回最小生成树的总权重
}

int main() {
    int n, m;
    cin >> n >> m;

    for (int i = 0; i < m; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
    }

    cout << "Minimum Cost of MST: " << prim(n) << endl;
    return 0;
}

时间复杂度：

使用优先队列实现时，普里姆算法的时间复杂度为 $O((V+E)\log V)$ ，其中 $V$ 是顶点数， $E$ 是边数。
这种时间复杂度适用于稠密图，即边数 $E$ 接近 $V^2$ 的图。

适用场景：

普里姆算法特别适用于稠密图，因为它从一个顶点开始构建最小生成树，逐步添加最近的顶点，适合于边比较多的情况。

2. 克鲁斯卡尔算法（Kruskal’s Algorithm）：

初始化：将图的所有边按照权重从小到大排序。
过程：遍历排序后的边列表，选择一条边，如果这条边不会与已经选择的边形成环，则加入到最小生成树中。
使用并查集（Disjoint Set Union, DSU）数据结构来帮助检测加入的边是否会形成环。
重复以上过程，直到选取的边数等于顶点数减一。

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct Edge {
    int u, v, weight;
    bool operator<(const Edge& other) const {
        return weight < other.weight;
    }
};

vector<Edge> edges;
int parent[MAXN];

int find(int x) {
    return parent[x] == x ? x : parent[x] = find(parent[x]);
}

void union_set(int x, int y) {
    parent[find(x)] = find(y);
}

int kruskal(int n) {
    sort(edges.begin(), edges.end());
    for (int i = 0; i < n; i++) {
        parent[i] = i;
    }

    int total_cost = 0;
    for (Edge &e : edges) {
        if (find(e.u) != find(e.v)) {
            total_cost += e.weight;
            union_set(e.u, e.v);
        }
    }

    return total_cost;
}

int main() {
    int n, m;
    cin >> n >> m;

    for (int i = 0; i < m; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        edges.push_back({u, v, w});
    }

    cout << "Minimum Cost of MST: " << kruskal(n) << endl;
    return 0;
}