普林姆算法

普里姆算法（）是图论中的一种贪心算法，可在一个加权连通图中找到其最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点，且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家发现；并在1957年由美国计算机科学家罗伯特·C·普里姆独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法。
描述.
从单一顶点开始，普里姆算法按照以下步骤逐步扩大树中所含顶点的数目，直到遍及连通图的所有顶点。
时间复杂度.
通过邻接矩阵图表示的简易实现中，找到所有最小权边共需formula_21的运行时间。使用简单的二叉堆与邻接表来表示的话，普里姆算法的运行时间则可缩减为formula_22，其中formula_23为连通图的边集大小，formula_24为点集大小。如果使用较为复杂的斐波那契堆，则可将运行时间进一步缩短为formula_25，这在连通图足够密集时（当formula_23满足formula_27条件时），可较显著地提高运行速度。
证明.
已知图G的边数量为numEdge, 顶点数量为numVert, prim生成的树为T0, 最小生成树（MST）为Tmin
则有，cost(Tmin)&lt;=cost(T0)
设：
T0 的 numVert-1 条边按照权重由小到大排列依次为：ek1, ek2, ek3, ..., ekn
Tmin 的 numVert-1 条边按照权重由小到大排列依次为：eg1, eg2, eg3, ..., egn
其中n=numVert-1
两棵树的边从小到大权重比较，设第一个属于 T0 但不属于 Tmin 的边为 ed1, 连接该边的两个顶点为 (vs, ve1)
同时存在第一个属于 Tmin 但不属于 T0 且以vs为顶点的边，记为 ed2, 连接该边的两个顶点为 (vs, ve2)。
两个边的起点相同。由Prim算法性质可知，w(ed2) &gt;= w(ed1)
此时，在 Tmin 中删除 ed2 ，添加 ed1，边的数量和顶点数量均不变，且不存在环，因此得到新的生成树Tnew,且cost(Tmin)&gt;=cost(Tnew)
又因为 Tmin 是MST 所以 cost(Tmin)=cost(Tnew)。
以此类推，cost(Tmin)=cost(T0)
T0是最小生成树， 得证.
各语言程序代码.
Pascal语言程序.
部分主程序段：
procedure prim(v0:integer);
var
 lowcost,closest:array[1..maxn] of integer;
 i,j,k,min,ans:integer;
 for i:=1 to n do
 begin
 lowcost[i]:=cost[v0,i];
 closest[i]:=v0;
 end;
 for i:=1 to n-1 do
 begin
 min:=maxint;
 for j:=1 to n do
 if (lowcost[j]&lt;min) and (lowcost[j]&lt;&gt;0) then
 begin
 min:=lowcost[j];
 k:=j;
 end;
 inc(ans, lowcost[k]);
 lowcost[k]:=0;
 for j:=1 to n do
 if cost[k,j]&lt;lowcost[j] then
 begin
 lowcost[j]:=cost[k,j];
 closest[j]:=k;
 end;
 end;
 writeln(ans);
end;
C语言代码.
//来源：严蔚敏 吴伟民《数据结构(C语言版)》
void MiniSpanTree_PRIM (MGraph G, VertexType u) {
 /* 用普利姆算法从第u个顶点出发构造网G 的最小生成树T,输出T的各条边。
 记录从顶点集U到V-U的代价最小的边的辅助数组定义：
 struct
 VertexType adjvex;
 VRtype lowcost;
 }closedge[MAX_VERTEX_NUM];
 
 k = LocateVex(G, u);
 for (j = 0 ; j &lt; G.vexnum; j++) { //辅助数组初始化
 if (j != k)
 for (i = 1; i &lt; G.vexnum ; i++) { //选择其余G.vexnum -1 个顶点
 k = minimum(closedge); //求出T的下个结点：第k结点
 printf(closedge[k].adjvex, G.vexs[k]); //输出生成树的边
 closedge[k].lowcost = 0; //第k条边并入U集
 for (j = 0; j &lt; G.vexnum; j++) {
 //新顶点并入U后重新选择最小边
 if (G.arcs[k][j].adj &lt; closedge[j].lowcost &amp;&amp; closedge[j].lowcost!=0) 
 closedge[j] = {G.vex[k], G.arcs[k][j].adj};
//来源： 浙大-陈越 《数据结构》
Vertex FindMinDist( MGraph Graph, WeightType dist[] )
 /* 返回未被收录顶点中dist最小者 */
 Vertex MinV, V;
 WeightType MinDist = INFINITY;
 for (V=0; V&lt;Graph-&gt;Nv; V++) {
 if ( dist[V]!=0 &amp;&amp; dist[V]&lt;MinDist) {
 /* 若V未被收录，且dist[V]更小 */
 MinDist = dist[V]; /* 更新最小距离 */
 MinV = V; /* 更新对应顶点 */
 if (MinDist &lt; INFINITY) /* 若找到最小dist */
 return MinV; /* 返回对应的顶点下标 */
 else return ERROR; /* 若这样的顶点不存在，返回-1作为标记 */
int Prim( MGraph Graph, LGraph MST )
 WeightType dist[MaxVertexNum], TotalWeight;
 Vertex parent[MaxVertexNum], V, W;
 int VCount;
 Edge E;
 /* 初始化。默认初始点下标是0 */
 for (V=0; V&lt;Graph-&gt;Nv; V++) {
 /* 这里假设若V到W没有直接的边，则Graph-&gt;G[V][W]定义为INFINITY */
 dist[V] = Graph-&gt;G[0][V];
 parent[V] = 0; /* 暂且定义所有顶点的父结点都是初始点0 */
 TotalWeight = 0; /* .
 ...初始化权重和 */
 VCount = 0; /* 初始化收录的顶点数 */
 /* 创建包含所有顶点但没有边的图。注意用邻接表版本 */
 MST = CreateGraph(Graph-&gt;Nv);
 E = (Edge)malloc( sizeof(struct ENode) ); /* 建立空的边结点 */
 /* 将初始点0收录进MST */
 dist[0] = 0;
 VCount ++;
 parent[0] = -1; /* 当前树根是0 */
 while (1) {
 V = FindMinDist( Graph, dist );
 /* V = 未被收录顶点中dist最小者 */
 if ( V==ERROR ) /* 若这样的V不存在 */
 break; /* 算法结束 */
 /* 将V及相应的边&lt;parent[V], V&gt;收录进MST */
 E-&gt;V1 = parent[V];
 E-&gt;V2 = V;
 E-&gt;Weight = dist[V];
 InsertEdge( MST, E );
 TotalWeight += dist[V];
 dist[V] = 0;
 VCount++;
 for( W=0; W&lt;Graph-&gt;Nv; W++ ) /* 对图中的每个顶点W */
 if ( dist[W]!=0 &amp;&amp; Graph-&gt;G[V][W]&lt;INFINITY ) {
 /* 若W是V的邻接点并且未被收录 */
 if ( Graph-&gt;G[V][W] &lt; dist[W] ) {
 /* 若收录V使得dist[W]变小 */
 dist[W] = Graph-&gt;G[V][W]; /* 更新dist[W] */
 parent[W] = V; /* 更新树 */
 } /* while结束*/
 if ( VCount &lt; Graph-&gt;Nv ) /* MST中收的顶点不到|V|个 */
 TotalWeight = ERROR;
 return TotalWeight; /* 算法执行完毕，返回最小权重和或错误标记 */
Python语言实现.
此份源码使用了堆优化
from queue import PriorityQueue as priority_queue
from math import inf
class Node:
 def __init__(self,id,**kwargs):
 self.id = id
 self.fst = self.lst = None
 def __iter__(self):
 return NodeIterator(self)
 def __repr__(self):
 return "Node(%d)"%self.id
class NodeIterator:
 def __init__(self,Node):
 self.prst = Node.fst
 def __next__(self):
 if self.prst == None:
 raise StopIteration()
 ret = self.prst
 self.prst = self.prst.nxt
 return ret
class Edge:
 def __init__(self,fr,to,**kwargs):
 if fr.fst == None:
 fr.fst = self
 else:
 fr.lst.nxt = self
 fr.lst = self
 self.to = to
 self.nxt = None
 self.w = 1 if 'w' not in kwargs else kwargs['w']
 def __repr__(self):
 return "Edge({},{},w = {})",format(self.fr,self.to,self.w)
class Graph:
 def __init__(self,V):
 self.nodecnt = V
 self.nodes = [Node(i) for i in range(V)]
 self.edges = []
 def add(self,u,v,**kwargs):
 self.edges.append(Edge(self.nodes[u],self.nodes[v],**kwargs))
 def MST_prim(self,begin):
 prim algorithm on a graph(with heap),
 returns the weight sum of the tree
 or -1 if impossible
 q = priority_queue()
 vis = [False for _ in range(self.nodecnt)]
 q.put((0,begin))
 ret = 0
 while not q.empty():
 prst = q.get()
 if vis[prst[1]]:
 continue
 vis[prst[1]] = True
 ret += prst[0]
 for i in self.nodes[prst[1]]:
 if not vis[i.to.id]:
 q.put((i.w,i.to.id))
 if all(vis):
 return ret
 else:
 return -1
Java语言实现.
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Prim {
 public static List&lt;Vertex&gt; vertexList = new ArrayList&lt;Vertex&gt;();//结点集
 public static List&lt;Edge&gt; EdgeQueue = new ArrayList&lt;Edge&gt;();//边集
 public static List&lt;Vertex&gt; newVertex = new ArrayList&lt;Vertex&gt;();//已经 访问过的结点
 public static void main(String[] args) {
 primTree();
 public static void buildGraph() {
 Vertex v1 = new Vertex("a");
 Prim.vertexList.add(v1);
 Vertex v2 = new Vertex("b");
 Prim.vertexList.add(v2);
 Vertex v3 = new Vertex("c");
 Prim.vertexList.add(v3);
 Vertex v4 = new Vertex("d");
 Prim.vertexList.add(v4);
 Vertex v5 = new Vertex("e");
 Prim.vertexList.add(v5);
 addEdge(v1, v2, 6);
 addEdge(v1, v3, 7);
 addEdge(v2, v3, 8);
 addEdge(v2, v5, 4);
 addEdge(v2, v4, 5);
 addEdge(v3, v4, 3);
 addEdge(v3, v5, 9);
 addEdge(v5, v4, 7);
 addEdge(v5, v1, 2);
 addEdge(v4, v2, 2);
 public static void addEdge(Vertex a, Vertex b, int w) {
 Edge e = new Edge(a, b, w);
 Prim.EdgeQueue.add(e);
 public static void primTree() {
 buildGraph();
 Vertex start = vertexList.get(0);
 newVertex.add(start);
 for (int n = 0; n &lt; vertexList.size() - 1; n++) {
 Vertex temp = new Vertex(start.key);
 Edge tempedge = new Edge(start, start, 1000);
 for (Vertex v : newVertex) {
 for (Edge e : EdgeQueue) {
 if (e.start == v &amp;&amp; !containVertex(e.end)) {
 if (e.key &lt; tempedge.key) {
 temp = e.end;
 tempedge = e;
 newVertex.add(temp);
 Iterator it = newVertex.iterator();
 while (it.hasNext()) {
 Vertex v = (Vertex) it.next();
 System.out.println(v.key);
 public static boolean containVertex(Vertex vte) {
 for (Vertex v : newVertex) {
 if (v.key.equals(vte.key))
 return true;
 return false;
class Vertex {
 String key;
 Vertex(String key) {
 this.key = key;
class Edge {
 Vertex start;
 Vertex end;
 int key;
 Edge(Vertex start, Vertex end, int key) {
 this.start = start;
 this.end = end;
 this.key = key;
参考.
普林演算法与迪科斯彻演算法的策略相似。