图论——最小生成树

最新推荐文章于 2024-05-04 14:49:08 发布

IGP9

最新推荐文章于 2024-05-04 14:49:08 发布

阅读量90

点赞数

分类专栏：算法文章标签：算法图论

本文链接：https://blog.csdn.net/qq_44965626/article/details/107589122

版权

算法专栏收录该内容

28 篇文章 0 订阅

订阅专栏

本文详细介绍了两种常见的最小生成树算法——Prim算法和Kruskal算法，包括它们的时间复杂度、基本思路及C++实现。Prim算法通过维护一个最小生成树集合，逐步加入最近的点；Kruskal算法则通过并查集合并子树，确保不形成环路。两种算法各有特点，Prim适合稠密图，Kruskal适合稀疏图。

摘要由CSDN通过智能技术生成

本文主要内容：

Prime算法求最小生成树
Kruskal算法求最小生成树

1 Prime算法求最小生成树

时间复杂度：
o(n²)
基本思路：

维护一个最小生成树集合
在集合外找一个距离集合最近的点加入集合，用该点更新其他所有点到集合的距离
原理同Dijkstra算法类似，堆优化也同Dijkstra算法的堆优化类似

模板题：Acwing858. Prim算法求最小生成树

#include<iostream>
#include<cstring>

using namespace std;

const int N = 505;

int g[N][N];
int n, m, dist[N];
bool st[N];

int prim()
{
    int res = 0;
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for(int i = 0; i < n; i++)
    {
        int t = -1;
        for(int j = 1; j <= n; j++)
            if(!st[j] && (t == -1 || dist[j] < dist[t]))
                t = j;
        if(dist[t] == 0x3f3f3f3f)return -1;
        res += dist[t];
        st[t] = true;
        for(int j = 1; j <= n; j++)
            dist[j] = min(dist[j], g[t][j]);
    }
    return res;
}

int main()
{
    memset(g, 0x3f, sizeof g);
    cin >> n >> m;
    while(m--)
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    int t = prim();
    if(t == -1)cout << "impossible";
    else cout << t;
    return 0;
}

堆优化版

#include<iostream>
#include<queue>
#include<cstring>

using namespace std;

typedef pair<int, int> PII;

const int N = 510, M = 2e5 + 10;

int e[M], ne[M], w[M], h[N], idx;
bool vis[N];
int n, m, ans, dist[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

bool prime()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>>heap;
    heap.push({0, 1});
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        int ver = t.second, distance = t.first;
        if(vis[ver])continue;
        vis[ver] = true;
        ans += distance;
        
        for(int i = h[ver]; ~i; i = ne[i])
        {
            int son = e[i], val = w[i];
            if(w[i] < dist[son])
            {
                dist[son] = w[i];
                heap.push({dist[son], son});
            }
        }
    }
    return dist[n] != 0x3f3f3f3f;
}
int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while(m--)
    {
        int u, v, w;
        cin >> u >> v >> w;
        add(u, v, w), add(v, u, w);
    }
    if(prime())cout << ans;
    else cout << "impossible";
    return 0;
}

2 Kruskal算法求最小生成树

时间复杂度：
o(mlogm)
基本思路：
1.利用并查集，最小生成树可看做一个集合，一开始有n个最小生成子树

每次用没有用过的最短的一条边合并该条边的两端点所在的最小生成子树（若两端点在同一子树则跳过）
若最终生成的最小生成子树有n-1条边，则该图的最小生成树存在，否则不存在

模板题：Acwing859. Kruskal算法求最小生成树

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 200010;

int p[N], n, m;

struct Edge
{
    int l, r, w;
    bool operator < (const Edge t)
    {
        return w < t.w;
    }
}edges[N];

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

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= m; i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        edges[i] = {u, v, w};
    }
    for(int i = 1; i <= n; i++)
        p[i] = i;
    sort(edges + 1, edges + 1 + m);
    int res = 0, cnt = 0;
    for(int i = 1; i <= m; i++)
    {
        Edge t = edges[i];
        int l = t.l, r = t.r, w = t.w;
        int pl = find(l), pr = find(r);
        if(pl != pr)
        {
            p[pl] = pr;
            res += w;
            cnt++;
        }
    }
    if(cnt < n - 1)cout << "impossible";
    else cout << res;
    return 0;