prim算法的邻接表和邻接矩阵实现

邻接矩阵版

const int maxn = 1000;
const int INF = 100000;
int n;   //n为点数
int G[maxn][maxn];
ind d[maxn];    //d[i]表示顶点i到集合S的最短距离
bool vis[maxn] = {false};

int prim()
{
    //初始化
    fill(d, d + maxn, INF);
    d[0] = 0;
    ans = 0;
    for(int i = 0; i < n; i++)
    {
        int u = -1, MIN = INF;
        for(int j = 0; j < n; j++)
        {
            if(vis[j] == false && d[j] < INF)
            {
                u = j;
                MIN = d[j];
            }
        }
        if(u == -1) return -1;
        vis[u] = true;
        ans += d[u];     //将与集合S距离最小的边加入最小生成树
        for(int v = 0; v < n; v++)
        {
            if(vis[v] == false && G[u][v] != INF && G[u][v] < d[v])
            {
                d[v] = G[u][v];
            }
        }
    }
    return ans;
}

邻接表版本

const int maxn = 1000;
const int INF = 100000;
struct node
{
    int v, dis;
};
vector<node> Adj[maxn];
int n;
int d[maxn];
bool vis[maxn] = {false};
int prim()
{
    fill(d, d + maxn, INF);
    d[0] = 0;
    int ans = 0;
    for(int i = 0; i < n; i++)
    {
        int u = -1, MIN = INF;
        for(int j = 0; j < n; j++)
        {
            if(vis[j] == false && d[j] < MIN)
            {
                u = j;
                MIN = d[j];
            }
        }
        if(u == -1) return -1;
        vis[u] = true;
        ans += d[u];	 //将与集合S距离最小的边加入最小生成树
        for(int j = 0; j < Adj[u].size(); j++)
        {
            int v = Adj[u][j].v;
            if(vis[v] == false && G[u][v] < d[v])
            {
                d[v] = G[u][v];
            }
        }
    }
    return ans;
}

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000;
const int INF = 100000;
int n, m;   //n为点数
int G[maxn][maxn];
int d[maxn];    //d[i]表示顶点i到集合S的最短距离
bool vis[maxn] = {false};

int prim()
{
    fill(d, d + maxn, INF);
    d[0] = 0;
    int ans = 0;
    for(int i = 0; i < n; i++)
    {
        int u = -1, MIN = INF;
        for(int j = 0; j < n; j++)
        {
            if(vis[j] == false && d[j] < MIN)
            {
                u = j;
                MIN = d[j];
            }
        }
        if(u == -1) return -1;
        vis[u] = true;
        ans += d[u];        //将与集合S距离最小的边加入最小生成树
        for(int v = 0; v < n; v++)
        {
            if(vis[v] == false && G[u][v] != INF && G[u][v] < d[v])
            {
                d[v] = G[u][v];
            }
        }
    }
    return ans;
}

int main()
{
    int u, v, w;
    scanf("%d%d", &n, &m);
    fill(G[0], G[0] + maxn * maxn, INF);
    for(int i = 0; i < m; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        G[u][v] = G[v][u]= w;       //无向图
    }
    int ans = prim();
    printf("%d\n", ans);
}

输入

6 10
0 1 4
0 4 1
0 5 2
1 2 6
1 5 3
2 3 6
2 5 5
3 4 4
3 5 5
4 5 3

输出

15