On this page:
1 Theme Song
2 The Testing Problem
3 Another Testing Strategy
4 Problem Statement
5 Efficiency
6 Built-Ins
7 Starter

MST

    1 Theme Song

    2 The Testing Problem

    3 Another Testing Strategy

    4 Problem Statement

    5 Efficiency

    6 Built-Ins

    7 Starter

In this assignment you will implement solutions to the Minimum Spanning Tree problem.

1 Theme Song

Spanning Tree Song by Radia Perlman, Dawn Perlner, and Ray Perlner

NB: Radia Perlman is one of the “parents of the Internet” and is in the Internet Hall of Fame. You’re using her ideas and work to read this page and to listen to that song.

2 The Testing Problem

In general, given a graph, an MST solution must produce a tree, that spans, and is minimal. There can be many solutions that are all minimal. Therefore, we should recognize this situation: it makes it difficult to write concrete test cases!

We can still check the above properties for a small number of concrete cases. In addition, checking that a purported solution is a tree and spans is not too hard. Therefore, we can in principle write an oracle. However, the property of minimality makes the combinatorics daunting: we must in principle enumerate every single tree, calculate its weight, determine the minimum of these, and confirm that the algorithm produces a solution with this weight. The tricky problem, therefore, is determining the weight of a minimal solution.

3 Another Testing Strategy

In this assignment we will pursue another strategy to validate the output. We have seen that there are multiple ways of computing minimal spanning trees. Therefore, we will implement two different algorithms for the same problem. We will then measure the weights produced by the two solutions and check that they’re the same.

Of course, the fact that they produce solutions of the same weight doesn’t mean they are both correct: they could both be wrong! However, to produce the same wrong weight over many inputs, they must have a correlated error. (This error could, for instance, be in code they share, such as an implementation of union-find.) To minimize for likelihood of a correlated error, you should also test on at least a few inputs for which you know the definitive minimum.

4 Problem Statement

We will use the following Graph data definition:

data Edge:

  | edge(a :: String, b :: String, weight :: Number)

end

 

type Graph = List<Edge>

Graphs should not contain any loops (i.e., self-edges).

In this assignment, you will implement two MST solutions:
  • mst-prim :: Graph -> Graph, which implements Prim’s algorithm.

  • mst-kruskal :: Graph -> Graph, which implements Kruskal’s algorithm.

Note that Prim’s algorithm is extremely similar to Dijkstra’s, so this will be an opportunity to reinforce their similarities and differences.

You must consider edges to be undirected (edge equality has been defined so that order of Edge.a and Edge.b doesn’t matter). However, the input will include edges in only one “direction”. For instance, a sample Graph might be [list: edge("A", "B", 3), edge("C", "B", 4), edge("C", "A", 5)].

It is possible for there to be multiple edges to exist between the same two vertices, but notice that they must be in the same direction. So it is valid to have: [list: edge("A","B",3), edge("A","B",5)] but not [list: edge("A","B",3), edge("B","A",5)].

Despite the fact that edges from "B" to "A", "B" to "C", and "A" to "C" are not explicitly listed, because the edges are undirected, you should treat them like they are there. (This implies that either version of a particular edge can be in the MST, but not both.) How you choose to handle this implementation-wise and testing-wise is left up to you.Hint: You could add all the edges in the opposite direction.

The weight of an edge can be 0 or negative. Furthermore, a path that starts and ends at the same vertex will form a cycle, thus making the graph not a tree.

Also implement:
  • generate-input :: Number -> Graph, which consumes a number and randomly produces a connected graph with that many vertices. How you actually do this is up to you; there’s no one “right” answer, and we’ll accept many different solutions so long as they incorporate randomness. (Note that a graph containing 0 or 1 vertices contains no edges, so make sure your output reflects this.)

  • mst-cmp :: Graph, Graph, Graph -> Boolean, which consumes a well-formed graph and two purported MSTs of the graph, and returns true exactly when the two solutions are both trees, spanning, have the same weight, and only contain edges in the original graph.

We expect you to write a reasonable set of interesting manual tests for mst-prim, mst-kruskal, and mst-cmp. You must especially be manually checking that these compute minimal weight solutions, as discussed in Another Testing Strategy.

Finally, also implement:

Of course, it’s possible that both algorithms are producing the wrong answer, in that the solution from neither is minimal. You should therefore create some interesting graphs manually and check that the weights of the result are minimal. These concrete tests would reside outside sort-o-cle. It is this combination of testing strategies that gives us some confidence that both implementations are, in fact, correct. These concrete tests would reside outside the oracle, which is strictly automated.

5 Efficiency

We are not considering efficiency of implementation in this assignment, but we will check that you indeed implemented Prim’s and Kruskal’s algorithms correctly.

6 Built-Ins

In addition to the allowed functions in the general guidelines, you can also use immutable string dictionaries.

You can use any of the union-find implementations shown in class or in the textbook. You may use ref fields for that specific purpose. However, you are not allowed to use ref or any form of mutation elsewhere in your program.

7 Starter

Template

There are no wheats and chaffs for this assignment.