## Description

For this assignment, you will code 3 different graph algorithms. This homework has many files included,

so be sure to read ALL of the documentation given before asking questions.

Graph Data Structure

You are provided a Graph class. The important methods to note from this class are:

• getVertices returns a Set of Vertex objects (another class provided to you) associated with a

graph.

• getEdges returns a Set of Edge objects (another class provided to you) associated with a graph.

• getAdjList returns a Map that maps Vertex objects to Lists of VertexDistance objects. This

Map is especially important for traversing the graph, as it will efficiently provide you the edges

adjacent to any vertex (the outgoing edges of any vertex). For example, consider an adjacency list

where vertex A is associated with a list that includes a VertexDistance object with vertex B and

distance 2 and another VertexDistance object with vertex C and distance 3. This implies that in

this graph, there is an edge from vertex A to vertex B of weight 2 and another edge from vertex A

to vertex C of weight 3.

Vertex Distance Data Structure

In the Graph class and Dijkstra’s algorithm, you will be using the VertexDistance class implementation

that we have provided. In the Graph class, this data structure is used by the adjacency list to represent

which vertices a vertex is connected to. In Dijkstra’s algorithm, you should use this data structure along

with a PriorityQueue. When utilizing VertexDistance in this algorithm, the vertex attribute should

represent the destination vertex and the distance attribute should represent the minimum cumulative

path cost from the source vertex to the destination vertex.

DFS

Depth-First Search is a search algorithm that visits vertices in a depth based order. Similar to pre/post/inorder traversal in BSTs, it depends on a Stack-like behavior to work. In your implementation, the Stack

will be the recursive stack, meaning you should not create a Stack data structure. It searches along one

path of vertices from the start vertex and backtracks once it hits a dead end or a visited vertex until it

finds another path to continue along. Your implementation of DFS must be recursive to receive

credit.

Single-Source Shortest Path (Dijkstra’s Algorithm)

The next algorithm is Dijkstra’s Algorithm. This algorithm finds the shortest path from one vertex

to all of the other vertices in the graph. This algorithm only works for non-negative edge weights, so

you may assume all edge weights for this algorithm will be non-negative. In order to keep track of the

cumulative distance from the source vertex to the vertices you visit in this algorithm, you will need to

use the VertexDistance data structure we are providing you. At any stage throughout the algorithm,

the PriorityQueue of VertexDistance objects will tell you which vertex currently has the minimum

cumulative distance from the source vertex.

There are two commonly implemented terminating condition variants for Dijkstra’s Algorithm. The

first variant is where you depend purely on the PriorityQueue to determine when to terminate. You only

terminate once the PriorityQueue is empty. The other variant, the classic variant, is the version where

you maintain both a PriorityQueue and a visited set. To terminate, still check if the PriorityQueue

4

Homework 08: GraphAlgorithms Due: See Canvas

is empty, but you can also terminate early once all the vertices are in the visited set. You should

implement the classic variant for this assignment. The classic variant, while using more memory,

is usually more time efficient since there is an extra condition that could allow it to terminate early.

Self-Loops and Parallel Edges

In this framework, self-loops and parallel edges work as you would expect. If you recall, self-loops are

edges from a vertex to itself. Parallel edges are multiple edges with the same orientation between two

vertices. In other words, parallel edges are edges that are incident on precisely the same vertices. These

cases are valid test cases, and you should expect them to be tested. However, most implementations of

these algorithms handle these cases automatically, so you shouldn’t have to worry too much about them

when implementing the algorithms.

Prim’s Algorithm

A tree is a graph that is acyclic and connected. A spanning tree is a subgraph that contains all the

vertices of the original graph and is a tree. An MST has two main qualities: being minimum and a

spanning tree. Being minimum dictates that the spanning tree’s sum of edge weights must be minimized.

By the properties of a spanning tree, any valid MST must have |V | − 1 edges in it. However, since

all undirected edges are specified as two directional edges, a valid MST for your implementation will

have 2(|V | − 1) edges in it.

Prim’s algorithm builds the MST outward from a single component, starting with a starting vertex.

At each step, the algorithm adds the cheapest edge connected to the incomplete MST that does not

cause a cycle. Cycle detection can be handled with a visited set like in Dijkstra’s..

Visualizations of Graphs

The directed graph used in the student tests is:

1

2 3

4

5

6

7

The undirected graph used in the student tests is:

A B

C

D E

F

7

5

4 3

8

2

1

6

5

Homework 08: GraphAlgorithms Due: See Canvas

Grading

Here is the grading breakdown for the assignment. There are various deductions not listed that are

incurred when breaking the rules listed in this PDF and in other various circumstances.

Methods:

DFS 20pts

Dijkstra’s 30pts

Prim’s 25pts

Other:

Checkstyle 10pts

Efficiency 15pts

Total: 100pts

Provided

The following file(s) have been provided to you. There are several, but we’ve noted the ones to edit.

1. GraphAlgorithms.java

This is the class in which you will implement the different graph algorithms. Feel free to add

private static helper methods but do not add any new public methods, new classes, instance variables, or static variables.

2. Graph.java

This class represents a graph. Do not modify this file.

3. Vertex.java

This class represents a vertex in the graph. Do not modify this file.

4. Edge.java

This class represents an edge in the graph. It contains the vertices connected to this edge and

its weight. Do not modify this file.

5. VertexDistance.java

This class holds a vertex and a distance together as a pair. It is meant to be used with Dijkstra’s algorithm. Do not modify this file.

6. GraphAlgorithmsStudentTests.java

This is the test class that contains a set of tests covering the basic algorithms in the GraphAlgorithms

class. It is not intended to be exhaustive and does not guarantee any type of grade. Write your

own tests to ensure you cover all edge cases. The graphs used for these tests are shown

above in the pdf.

Deliverables

You must submit all of the following file(s). Make sure all file(s) listed below are in each submission, as

only the last submission will be graded. Make sure the filename(s) matches the filename(s) below, and

that only the following file(s) are present. Do NOT submit Graph.java, Vertex.java, Edge.java, or

6

Homework 08: GraphAlgorithms Due: See Canvas

VertexDistance.java, or else your submission will not compile on Gradescope.

Once submitted, double check that it has uploaded properly on Gradescope. To do this, download

your uploaded file(s) to a new folder, copy over the support file(s), recompile, and run. It is your sole

responsibility to re-test your submission and discover editing oddities, upload issues, etc.

1. GraphAlgorithms.java