CSC 226 ALGORITHMS AND DATA STRUCTURES II ASSIGNMENT 4 – PROGRAM AND WRITTEN

Description

1 Programming Assignment
The assignment is to implement an algorithm to compute the shortest (i.e. lowest weight) path between
two vertices of an edge-weighted graph. A Java template has been provided containing an empty method
ShortestPath, which takes a single argument consisting of a weighted adjacency matrix for an edgeweighted graph 𝐺. The expected behavior of the method is as follows:
Input: An 𝑛 × 𝑛 array 𝐺 representing an edge-weighted graph.
Output: An integer value corresponding to the total weight of a minimum weight path from vertex
0 to vertex 1.
For full marks, the finished ShortestPath function must implement Dijkstra’s algorithm and use a heapbased priority queue to select the nest vertex at each step. It is not necessary to store a specific minimum
weight path, only to determine the total weight of such a path. For example, consider the edge-weighted
graph below.
The total weight of a minimum weight path from vertex 0 to vertex 1 is 18. One such minimum weight
path is highlighted (note that there may be more than one path with minimum weight.)
You must use the provided Java template as the basis of your submission, and put your implementation
inside the ShortestPath method in the template. You may not change the name, return type or parameters
of the ShortestPath method. You may add additional methods as needed. The main method in the
template contains code to help you test your implementation by entering test data or reading it from a file.
You may modify the main method to help with testing, but only the contents of the ShortestPath method
(and any methods you have added) will be marked, since the main function will be deleted before marking
begins. Please read through the comments in the template file before starting.
2 Input Format
The testing code in the main function of the template reads a sequence of graphs in a weighted adjacency
matrix format and uses the ShortestPath function to compute the weight of a minimum 0-1 path for
each graph. A weighted adjacency matrix 𝐴 for an edge-weighted graph 𝐺 on 𝑛 vertices is an 𝑛 × 𝑛
matrix where entry (𝑖,𝑗) gives the weight of the edge between vertices 𝑖 and 𝑗 (or 0 if no edge exists).
For example, the matrix

corresponds to the edge-weighted graph in the previous section. Note that the weighted adjacency matrix
for an undirected graph is always symmetric.
The input format used by the testing code in main consists of the number of vertices 𝑛 followed by the
𝑛 × 𝑛 weighted adjacency matrix. The graph above would be specified as follows:
8
0 0 0 0 0 12 13 0
0 0 6 0 0 0 0 3
0 6 0 4 0 0 0 5
0 0 4 0 10 0 0 7
0 0 0 10 0 11 8 9
12 0 0 0 11 0 1 0
13 0 0 0 8 1 0 2
0 3 5 7 9 0 2 0
3 Test Datasets
A collection of randomly generated edge-weighted graphs has been uploaded to conneX. Your
assignment will be tested on graphs similar but not identical to the uploaded graphs. You are encouraged
to create your own test inputs to ensure that your implementation functions correctly in all cases.
4 Sample Run
The output of a model solution on the graph above is given in the listing below. Console input is shown
in blue.
Reading input values from stdin.
Reading graph 1
8
0 0 0 0 0 12 13 0
0 0 6 0 0 0 0 3
0 6 0 4 0 0 0 5
0 0 4 0 10 0 0 7
0 0 0 10 0 11 8 9
12 0 0 0 11 0 1 0
13 0 0 0 8 1 0 2
0 3 5 7 9 0 2 0
Graph 1: Minimum weight of a 0-1 path is 18
Processed 1 graph.
Average Time (seconds): 0.00
5 Evaluation Criteria
The programming assignment will be marked out of 25, based on a combination of automated testing
and human inspection, based on the criteria in the table below. The running times in the table assume
an input graph with 𝑛 vertices and 𝑚 edges.
Score (/25) Description
0 – 5 Submission does not compile or does not conform to the
provided template.
6 – 15 The implemented algorithm is not that of Dijkstra or is
substantially inaccurate on the tested inputs.
15 – 20 The implemented algorithm is accurate on all tested
inputs and has an 𝑂(𝑛
2 + 𝑚 log 𝑛) running time.
20 – 25 The implemented algorithm is accurate on all tested
inputs, uses a heap-based priority queue to select the next
vertex at each step and has an 𝑂(𝑛
2 + 𝑚 log 𝑛) running
time.
To be properly tested, every submission must compile correctly as submitted, and must be based on the
provided template. You may only submit one source file. If your submission does not compile for any
reason (even trivial mistakes like typos), or was not based on the template, it will receive at most
5 out of 25. The best way to make sure your submission is correct is to download it from conneX after
submitting and test it. You are not permitted to revise your submission after the due date, and late
submissions will not be accepted, so you should ensure that you have submitted the correct version of
your code before the due date. The conneX site will usually allow you to change your submission before
the due date if you notice a mistake. After submitting your assignment, conneX will automatically send
you a confirmation email. If you do not receive such an email, your submission was not received. If you
have problems with the submission process, send an email to the instructor before the due date.

CSC 226 FALL 2016
ALGORITHMS AND DATA STRUCTURES II
ASSIGNMENT 4 – WRITTEN
UNIVERSITY OF VICTORIA
1. Write a pseudocode description of the printLCS() algorithm, which prints the longest common
subsequence of two strings 𝑥 and 𝑦. Your algorithm takes as input the completed llcs[][] integer
array of longest common subsequence lengths, and the two strings 𝑥 and 𝑦. (So, you do not have the
path[][] array – see Lecture 17, slides 98 and 99.) Your algorithm should start at llcs[n][m]
and work its way down to llcs[i][j] where either i = 0 or j = 0 and it should run in 𝑂(𝑛 +
𝑚) time where 𝑛 is the length of 𝑥 and 𝑚 is the length of 𝑦.
2. Let 𝑁 be a flow network, and let 𝑓 be a flow for 𝑁. Prove that for any cut, , of 𝑁, the value of 𝑓 is
equal to the flow across cut , that is, |𝑓| = 𝑓().
3. Consider the following graph 𝐺. The edges have costs and are undirected. There are 7 vertices and 10
edges. The edge list 𝐸 is as follows:
(𝐴, 𝐵) (𝐴,𝐷) (𝐴, 𝑆) (𝐵, 𝐸) (𝐵, 𝐹) (𝐵, 𝑆) (𝐶, 𝐹) (𝐶, 𝑆) (𝐷, 𝐸) (𝐸, 𝐹)
The Bellman-Ford algorithm makes |𝑉| − 1 = 7 − 1 = 6 passes through the edge list 𝐸. Each pass
relaxes the edges in the order they appear in the edge list. As with Dijkstra’s algorithm, we record the
current best known cost 𝐷[𝑉] to reach each vertex 𝑉 from the start vertex 𝑆. Initially 𝐷[𝑆] = 0 and
𝐷[𝑉] = +∞ for all the other vertices 𝑉 ≠ 𝑆. Run Bellman-Ford on the given graph, starting at vertex
𝑆, and using the order of set 𝐸 above, show me the contents of array 𝐷[] after each iteration (6 arrays
in all.)
𝐴
V
A
𝑆
t
𝐵
V
A
𝐶
V
C
V
A
C
𝐷
V
C
V
A
C
𝐸
V
C
V
A
C
𝐹
V
C
V
A
C
2
3
9
1
2
2
4
4
1
8