prim最小生成树算法（堆优化）

prim算法原理和dijkstra算法差不多，依然不能处理负边

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 struct edge
 4 {
 5     int u,v,w,nxt;
 6 };
 7 edge e[100010];//建边
 8 bool f[110];//判断该点是否被染过色
 9 struct node
10 {
11     int dis,t;
12 };
13 node nod[110];//存点
14 int n,cnt,total;// n 点数 cnt 计数器 total 最小生成树的边权和
15 int h[110];//记录每个点发出的最后一条边的编号
16 void add(int,int,int);//函数声明
17 struct cmp
18 {
19     bool operator()(node a,node b)
20     {
21         return a.dis>b.dis;
22     }
23 };//定义比较函数，别忘了';'
24 priority_queue<node,vector<node>,cmp> q;//定义结构体优先队列存点
25 void prim()//堆优化
26 {
27     while(!q.empty()&&cnt<n)//cnt 判断是否达到n-1条边
28     {
29         while(!q.empty()&&f[q.top().t]) q.pop();//判断队首元素是否被标记，若被标记，踢出
30         //加这个的原因是每加一个元素，他不会更新已经在队列中的元素，而是作为新元素加入队列
31         if(q.empty())   break;//如果堆为空，说明都打过标记了，那也就没有继续下去的必要了，退出即可，这里可能会被卡时间
32         node k=q.top();//取队首元素
33         int u=k.t;//取队首元素标号
34         f[u]=1;//打标记
35         total+=nod[u].dis;//记录最小生成树的边权和
36         q.pop();//弹出
37         for(int i=h[u];i;i=e[i].nxt)//邻接表遍历，更新值
38         {
39             int v=e[i].v,w=e[i].w;//取终点和边权
40             if(w<nod[v].dis)//判断边权是否更小
41             {
42                 nod[v].dis=w;//更新值
43                 q.push(nod[v]);//入队
44             }
45         }
46         cnt++;//记录已经找到了的边的数量
47     }
48 }
49 int main()
50 {
51     scanf("%d",&n);//输入点数
52     for(int i=1;i<=n;++i)
53     {
54         nod[i].dis=0x3f3f3f;//初始化
55         nod[i].t=i;//记录点的标号
56     }
57     for(int i=1;i<=n;++i)
58     {
59         for(int j=1;j<=n;++j)//循环建边，根据题目来
60         {
61             int w;
62             scanf("%d",&w);
63             if(w)
64             {
65                 add(i,j,w);//建边
66                 add(j,i,w);
67             }
68         }
69     }
70     nod[1].dis=0;//起点到自己的距离是0
71     q.push(nod[1]);//入队
72     cnt=0;//初始化计数器（循环利用）
73     prim();//prim算法
74     printf("%d",total);
75     return 0;//结束
76 }
77 void add(int u,int v,int w)//加边
78 {
79     e[++cnt].u=u;
80     e[cnt].v=v;
81     e[cnt].w=w;
82     e[cnt].nxt=h[u];
83     h[u]=cnt;
84 }

重载运算符版本

 1 #include<bits/stdc++.h>
 2 #define ll long long
 3 #define rll register long long
 4 using namespace std;
 5 ll n,m,cnt,tot;
 6 ll h[5010];
 7 bool flag[5010];
 8 struct edge
 9 {
10     ll u,v,w,nxt;
11 };
12 edge e[400010];
13 struct node
14 {
15     ll t,dis;
16     bool operator < (const node &b) const
17     {
18         return dis>b.dis;
19     }//重载运算符
20 };
21 node nod[5010];
22 priority_queue<node> q;
23 void add(ll,ll,ll);
24 void prim();
25 int main()
26 {
27     scanf("%lld%lld",&n,&m);
28     for(rll i=1;i<=n;++i)
29     {
30         nod[i].dis=0x3f3f3f;
31         nod[i].t=i;
32     }
33     for(rll u,v,w,i=1;i<=m;++i)
34     {
35         scanf("%lld%lld%lld",&u,&v,&w);
36         add(u,v,w);
37         add(v,u,w);
38     }
39     nod[1].dis=0;
40     q.push(nod[1]);
41     cnt=0;
42     prim();
43     printf("%lld",tot);
44     return 0;
45 }
46 void add(ll u,ll v,ll w)
47 {
48     e[++cnt].u=u;
49     e[cnt].v=v;
50     e[cnt].w=w;
51     e[cnt].nxt=h[u];
52     h[u]=cnt;
53 }
54 void prim()
55 {
56     while(!q.empty()&&cnt<n)
57     {
58         while(!q.empty()&&flag[q.top().t])  q.pop();
59         if(q.empty())   break;//上一个代码讲了
60         node g=q.top();
61         ll u=g.t;
62         flag[u]=true;
63         tot+=nod[u].dis;
64         q.pop();
65         for(rll i=h[u];i;i=e[i].nxt)
66         {
67             ll v=e[i].v,w=e[i].w;
68             if(w<nod[v].dis)
69             {
70                 nod[v].dis=w;
71                 q.push(nod[v]);
72             }
73         }
74         cnt++;
75     }
76 }