Prim算法 C++

Prim算法是一种用于求最小生成树的算法。最小生成树是一幅连通加权无向图中的一颗边权和最小的生成树（即连接所有顶点的树）。

Prim算法的基本思想是从某一个初始顶点开始，逐步构建最小生成树。首先选择一个顶点作为起始点，然后将该顶点标记为已访问。然后，从已经选择的顶点中找到所有与之相邻的顶点，并计算这些顶点与已选择的顶点的边权。选择其中边权最小的边，将对应的顶点标记为已访问，并将边加入到最小生成树中。不断重复这个过程，直到所有顶点都被访问过。

具体实现上，可以使用优先队列来存储待选的边，每次选择边权最小的边进行访问。通过维护一个数组来标记是否访问过顶点，以及一个数组来记录每个顶点的最小生成树的边。

Prim算法的时间复杂度为O((V+E)logV)，其中V为顶点数，E为边数。

Prim算法是一种用于解决最小生成树问题的贪心算法。它的优点和缺点如下：

优点：
1. 算法简单直观，易于理解和实现。
2. 算法的时间复杂度为O(V^2)，其中V是顶点的数量。在顶点数量较小的情况下，算法的运行时间短。
3. 算法保证了生成的最小生成树是原图的子图，即包含了所有顶点。
4. 算法对于稠密图效果较好，即边的数量接近顶点数量的平方。

缺点：
1. 算法的时间复杂度较高，在稀疏图的情况下，边的数量远小于顶点数量的平方，算法的时间复杂度接近O(V^3)。
2. 算法每次选择一个顶点加入最小生成树，因此对于图中每个顶点都需要进行判断和更新，而不仅仅是处理边。这使得算法在处理大规模图时效率较低。

总的来说，Prim算法是一种简单直观的构建最小生成树的方法，适用于顶点数量较小，边的数量较大或者稠密的图。

 Prim算法 c++实现:

#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define KUI ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
struct jgt
{
    int go, d;
};
const int con = 2e5 + 5;
const int inf = 2139062143;
int n, m, k;
int dis[con];
bool vis[con];
vector<struct jgt> v[con];
void Prim()
{
    int sum = 0;
    dis[1] = 0;
    for (int i = 1; i <= n; i++)
    {
        k = 0;
        for (int j = 1; j <= n; j++)
        {
            if (vis[j] == 0 && dis[j] < dis[k])
            {
                k = j; // 贪心求最短距离;
            }
        }
        vis[k] = 1;
        sum += dis[k];
        for (auto &x : v[k])
        {
            if (dis[x.go] > x.d)
            {
                // Prim算法和Dijkstra算法很像,但是细节上还有区别;
                // Prim算法求最小生成树各边权值和最低,因此我们每次更新dis为最小的权值(dis为该节点相邻权值边的最小值);
                // Dijkstra算法求单个点到其余各个点的最短距离,dis更新为上一个节点加上到该节点的距离;
                dis[x.go] = x.d;
            }
        }
    }
    cout << sum << endl;
}
void take()
{
    cin >> n >> m;
    memset(dis, 127, sizeof(dis));
    struct jgt ans;
    for (int i = 1; i <= m; i++)
    {
        int a1, a2, a3;
        cin >> a1 >> a2 >> a3;
        ans.go = a2;
        ans.d = a3;
        v[a1].push_back(ans);
        ans.go = a1;
        v[a2].push_back(ans);
    }
    Prim();
}
int main()
{
    KUI;
    int t1 = 1;
    // cin >> t1;
    while (t1--)
    {
        take();
    }
    return 0;
}

优先队列优化 Prim算法 c++实现: 

#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define KUI ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
struct jgt
{
    int go, d;
};
struct jgt2
{
    int po, d;
    friend bool operator<(struct jgt2 x, struct jgt2 y)
    {
        if (x.d != y.d)
        {
            return x.d > y.d;
        }
        else
        {
            return x.po > y.po;
        }
    }
};
const int con = 2e5 + 5;
const int inf = 2139062143;
int n, m, k;
int dis[con];
bool vis[con];
vector<struct jgt> v[con];
priority_queue<struct jgt2> pq;
void Prim()
{
    int sum = 0;
    struct jgt2 ans, ans1;
    ans.po = 1;
    ans.d = 0;
    dis[1] = 0;
    pq.push(ans);
    while (pq.size() > 0)
    {
        ans = pq.top();
        pq.pop();
        if (vis[ans.po] == 1) // 如果已经走过了就继续出队下一个节点;
        {
            continue;
        }
        vis[ans.po] = 1;
        sum += ans.d;
        for (auto &x : v[ans.po])
        {
            if (dis[x.go] > x.d)
            {
                // Prim算法和Dijkstra算法很像,但是细节上还有区别;
                // Prim算法求最小生成树各边权值和最低,因此我们每次更新dis为最小的权值(dis为该节点相邻权值边的最小值);
                // Dijkstra算法求单个点到其余各个点的最短距离,dis更新为上一个节点加上到该节点的距离;
                dis[x.go] = x.d;
                ans1.po = x.go;
                ans1.d = x.d;
                pq.push(ans1);
            }
        }
    }
    cout << sum << endl;
}
void take()
{
    cin >> n >> m;
    memset(dis, 127, sizeof(dis)); // 距离初始值赋较大值;
    struct jgt ans;
    for (int i = 1; i <= m; i++)
    {
        int a1, a2, a3;
        cin >> a1 >> a2 >> a3;
        ans.go = a2;
        ans.d = a3;
        v[a1].push_back(ans);
        ans.go = a1;
        v[a2].push_back(ans);
    }
    Prim();
}
int main()
{
    KUI;
    int t1 = 1;
    // cin >> t1;
    while (t1--)
    {
        take();
    }
    return 0;
}