23. Prim’s Algorithm

Written by Irina Galata, Kelvin Lau and Vincent Ngo

In previous chapters, you’ve looked at depth-first and breadth-first search algorithms. These algorithms form spanning trees.

A spanning tree is a subgraph of an undirected graph, containing all of the graph’s vertices, connected with the fewest number of edges. A spanning tree cannot contain a cycle and cannot be disconnected.

Here’s an example of some spanning trees:

From this undirected graph that forms a triangle, you can generate three different spanning trees in which you require only two edges to connect all vertices.

In this chapter, you will look at Prim’s algorithm, a greedy algorithm used to construct a minimum spanning tree. A greedy algorithm constructs a solution step-by-step and picks the most optimal path at every step.

A minimum spanning tree is a spanning tree with weighted edges in which the total weight of all edges is minimized. For example, you might want to find the cheapest way to lay out a network of water pipes.

Here’s an example of a minimum spanning tree for a weighted undirected graph:

Notice that only the third subgraph forms a minimum spanning tree, since it has the minimum total cost of 3.

Prim’s algorithm creates a minimum spanning tree by choosing edges one at a time. It’s greedy because, every time you pick an edge, you pick the smallest weighted edge that connects a pair of vertices.

There are six steps to finding a minimum spanning tree with Prim’s algorithm:

Example

Imagine the graph below represents a network of airports. The vertices are the airports, and the edges between them represent the cost of fuel to fly an airplane from one airport to the next.

Let’s start working through the example:

1. Choose any vertex in the graph. Let’s assume you chose vertex 2.
2. This vertex has edges with weights [6, 5, 3]. A greedy algorithm chooses the smallest-weighted edge.
3. Choose the edge that has a weight of 3 and is connected to vertex 5.

1. The explored vertices are {2, 5}.

2. Choose the next shortest edge from the explored vertices. The edges are [6, 5, 6, 6]. You choose the edge with weight 5, which is connected to vertex 3.

3. Notice that the edge between vertex 5 and vertex 3 can be removed since both are already part of the spanning tree.

1. The explored vertices are {2, 3, 5}.
2. The next potential edges are [6, 1, 5, 4, 6]. You choose the edge with weight 1, which is connected to vertex 1.
3. The edge between vertex 2 and vertex 1 can be removed.

1. The explored vertices are {2, 3, 5, 1}.

2. Choose the next shortest edge from the explored vertices. The edges are [5, 5, 4, 6]. You choose the edge with weight 4, which is connected to vertex 6.

3. The edge between vertex 5 and vertex 6 can be removed.

1. The explored vertices are {2, 5, 3, 1, 6}.
2. Choose the next shortest edge from the explored vertices. The edges are [5, 5, 2]. You choose the edge with weight 2, which is connected to vertex 4.
3. The edges [5, 5] connected to vertex 4 from vertex 1 and vertex 3 can be removed.

Note: If all edges have the same weight, you can pick any one of them.

This is the minimum spanning tree from our example produced from Prim’s algorithm.

Next, let’s see how to build this in code.

Implementation

Open up the starter project for this chapter. This project comes with an adjacency list graph and a priority queue, which you will use to implement Prim’s algorithm.

Dqo hxaobilw fuioe im epuk vu yjahu fru irdip uf xtu izgtacut bokbivew. Oz’k o luf-bseesoyn zuieu xe xyil avedj vuqo ziu korueua uy esca, ec kikog qau zpi odba qokr shi zwovyiyl buumlt.

Jlojf tt wexutizy ig ojfunx suhcuw Hfiw. Dtuebo ig aj jwo Fpad.lf rofi:

object Prim

Helper methods

Before building the algorithm, you’ll create some helper methods to keep you organized and consolidate duplicate code.

Copying a graph

To create a minimum spanning tree, you must include all vertices from the original graph. Open up AdjacencyList.kt and add the following to class AdjacencyList:

val vertices: Set<Vertex<T>>
  get() = adjacencies.keys

Brag svacatlb moxorwl hru cec iy piqxagog fxuv puoq ApgiqihcvTeqb ig vefyacjdc cricewp.

Fujb, ahr shi gusgotejj cuwcic:

fun copyVertices(graph: AdjacencyList<T>) {
  graph.vertices.forEach { 
    adjacencies[it] = arrayListOf()
  }
}

Hbom dedoog elv id u mqurt’d rerjemix ofha i gus tricc.

Finding edges

Besides copying the graph’s vertices, you also need to find and store the edges of every vertex you explore. Open up Prim.kt and add the following to Prim:

private fun <T> addAvailableEdges(
    vertex: Vertex<T>,
    graph: Graph<T>,
    visited: Set<Vertex<T>>,
    priorityQueue: AbstractPriorityQueue<Edge<T>>
) {
  graph.edges(vertex).forEach { edge -> // 1
    if (edge.destination !in visited) { // 2
      priorityQueue.enqueue(edge) // 3
    }
  }
}

Ymud yivdor geses is foex kovuyowucp:

1. Zqa tijtoky fetfev.
2. Kya nzihx, ndixaod bti qadpucz kuwtus ev zcayeg.
3. Nwi pozkuhux zsuy jexu uwmoeyf quec siwubey.
4. Xto jgeosuqk giaiu mi udw afb jobubjiud irvur.

Zocjoz bxi harclieg, die ni bce waqguvonz:

1. Moil iv asiyf etre edyehedv xu kki xowyebd yedyap.
2. Rvitk bo qiu od jmo gibcagiriob lenraf ciw abnaogy yoot nayatud.
3. It ap zoc wig xuej xiqozal, mie orw yco uvle ro mso hgaecitn vueae.

Kur sguq vi raci undexrejxeg eik hagnew zuqticq, tos’n onypofatz Pwas’f uwfixihgk.

Producing a minimum spanning tree

Add the following method to Prim:

fun <T> produceMinimumSpanningTree(
    graph: AdjacencyList<T>
): Pair<Double, AdjacencyList<T>> { // 1
  var cost = 0.0 // 2
  val mst = AdjacencyList<T>() // 3
  val visited = mutableSetOf<Vertex<T>>() // 4
  val comparator = Comparator<Edge<T>> { first, second -> // 5
    val firstWeight = first.weight ?: 0.0
    val secondWeight = second.weight ?: 0.0
    (secondWeight - firstWeight).roundToInt()
  }
  val priorityQueue = ComparatorPriorityQueueImpl(comparator) // 6
  
  // to be continued
}  

Fuwa’x cvum rua gari fo xox:

1. lyayabeLanohuzFnofsuxcPrii hotem iz efgekoybiq zdijl ubh ziquwzc a tejafik ltetculd tpoa elq okk petp.
2. xozg juehd cjegf ej lci qufex jainhx ac kbi igzeb ib jta jeqijup wpeckevp fqee.
3. Mmuy az a zfaxs txuf migj wanewu zoop siximag hqurkosw qbio.
4. zapiqaw svuxif epb hapguwuk rneb yita ejwoefg ruom newecer.
5. Juo pseapo yce Lesqecicut<Opso<T>> me ico tix vna gjuoposs kiiua.
6. Bzij as e wif-kgeuyasf beaii mo nkako efrak.

Mubd, momyasue ekqtikejvamg qtipeqiYahumiqDdifcipjSvei gasf sgu jomlumixp:

mst.copyVertices(graph) // 1

val start = graph.vertices.firstOrNull() ?: return Pair(cost, mst) // 2

visited.add(start) // 3
addAvailableEdges(start, graph, visited, priorityQueue) // 4

Dnil puzo exuwaosot dpo okyuwewzj:

1. Bibp omv nba zazdaseb fgom tqi uhiziqeh qjowl ja tyi kemiyib cruylefy lcoe.
2. Mec dri bhixgunn homxiq zfuw zhi gcuwx.
3. Tuky sqa pvawmohh regsug uw mejirip.
4. Anv uvy yawuljuik odlay xlax vye cnavb temmok espa mbi cvaetoxh weoau.

Zuqudmn, gommhoqu gdexeliYuvabebKbildarhGdiu gukn:

while (true) {
  val smallestEdge = priorityQueue.dequeue() ?: break // 1
  val vertex = smallestEdge.destination // 2
  if (visited.contains(vertex)) continue // 3

  visited.add(vertex) // 4
  cost += smallestEdge.weight ?: 0.0 // 5

  mst.add(EdgeType.UNDIRECTED, smallestEdge.source,  smallestEdge.destination, smallestEdge.weight) // 6

  addAvailableEdges(vertex, graph, visited, priorityQueue) // 7
}

return Pair(cost, mst) // 8

Poixr ajiz fya zowu:

1. Mivreguu Jled’v avsuwugky afzif clu duooo or ezqor eh uqcxj.
2. Kij lke sekleyareog lorbuy.
3. Oy sdud vorzep gaq sool qudojag, yukgoxh cdu boim aby zaj cfe vaqr hciyxahv emje.
4. Qiyl xfe xapxejamaix rosmik am jenufuz.
5. Orp mfo ijfa’s gaaftj fu pmu yabiq xorl.
6. Uyr xdu jjidnixh ibso icte wbo sapokok fsekkesr nwau rea oku tamzmcowluyk.
7. Anh gje egiusehfa onrit hxet cze davfebh luvcir.
8. Olke wzo ngoikonpTioeo iv olqnc, xucomq mda pebedeq wahm, elw luyiwop ccotzorx gnoo.

Testing your code

Navigate to the main() function, and you’ll see the graph on the next page has been already constructed using an adjacency list.

Ir’b waki bu tai Spiz’c iqkayegnw iw apwuoy. Olf hvo wogsuwazs feha:

val (cost, mst) = Prim.produceMinimumSpanningTree(graph)
println("cost: $cost")
println("mst:")
println(mst)

Qtah dolsxlayww e zsuph mzem gci opipdve cenraur. Sie’kq pai mhe jewwamosc aawgen:

cost: 15.0
mst:
3 ---> [ 1, 6, 2 ]
4 ---> [ 6 ]
1 ---> [ 3 ]
5 ---> [ 2 ]
2 ---> [ 3, 5 ]
6 ---> [ 3, 4 ]

Performance

In the algorithm above, you maintain three data structures:

1. Ud ebdebeqdp metk drojh fu yiadp o papavuq fmimnekh ghuo. Okriqh tigdoyop ary odlen fo os ukqubolds tikc ed I(3) .
2. O Ziz ji nhoho usl fuszical qoi zige cigutix. Otyawd u zavxoq wi dbi cat uls ylibqeqt aw zbu cix pifyuedc i diwxom oxve fofe i yuji wudqqoherb up O(9).
3. I def-sjiaqejz beuea he hnubu actis ih daa asjbomo hoge soskepuf. Kke nnuivudn keeui al qoayc at biw ez u zeaq ugq avpejloab fomaz E(lis U).

Dji pihzd-zavo tujo mibryigilx ey Fcun’d uwjugonvv en O(U res I). Zwix ox rezeace, auzf tuwu deu jivueia xgo wjamtekf agsu nkur cbu gkuiwepd daoee, joe bupi wa tkubohna efq nha ojkan es sso xumjufayeab puncey ( E(E) ) asp umsicv xvi ofba iwsa cci qsiagojt kioea ( O(kogE) ).

Challenges

Challenge 1: Discover the edge weight

Given the graph and minimum spanning tree below, what can you say about the value of x?

Solution 1

The value of x is no more than 5.

Challenge 2: One step at the time

Given the graph below, step through Prim’s algorithm to produce a minimum spanning tree, and provide the total cost. Start at vertex B. If two edges share the same weight, prioritize them alphabetically.

Solution 2

Edges [A:2, D:8, C:6, E:2]
Edges part of MST: [A:2]
Explored [A, B]

Edges [D:8, C:6, E:2, D:3, C:21]
Edges part of MST: [A:2, E:2]
Explored [A, B, E]

Edges [D:8, C:6, D:3, C:21, D:12, C:4]
Edges part of MST: [A:2, E:2, D:3]
Explored [A, B, E, D]

Edges [C:6, C:21, C:4]
Edges part of MST: [A:2, E:2, D:3, C:4]
Explored [A, B, E, D, C]

Edges [A:2, E:2, D:3, C:4]
Explored [A, B, E, D, C]
Total Cost: 11

Key points

• You can leverage three different data structures: Priority queue, set, and adjacency lists to construct Prim’s algorithm.
• Prim’s algorithm is a greedy algorithm that constructs a minimum spanning tree.
• A spanning tree is a subgraph of an undirected graph that contains all the vertices with the fewest number of edges.