For any Assignment related queries, Call us at :- +1 678 648 4277

Visit :- https://computernetworkassignmenthelp.com/ ,
Email :- support@computernetworkassignmenthelp.com or

Design & Analysis Of Algorithms

Assignment Help
Problem 6-1. Dynamic and Bounded-Hop All-Pairs Shortest Paths
This problem explores some extensions of the All-Pairs Shortest Paths
(APSP) algorithms covered in lecture and in CLRS. All parts of this problem
assume nonnegative real weights. We assume that the vertices are
numbered 1, 2, . . . , n.
Weighted directed graphs may be used to model communication networks,
and shortest distances (shortest-path weights) between nodes may be used
to suggest routes for messages. However, most communication networks
are dynamic, i.e., the weights of edges may change over time. So it is useful
to have a way of modifying distance estimates to reflect these changes.
(a) Give an efficient algorithm that, given a weighted directed graph G = (V,
E, W), a correct distance matrix D for G, a corresponding predecessor
matrix Π, and a triple (i, j, r), where i, j ∈ V and r is a nonnegative real,
modifies D and Π to reflect the effects of changing wi,j to r. Your
algorithm will need to handle three cases: r = wi,j , r < wi,j , and r > wi,j .
For each of the cases, analyze
your algorithm. (Note: Your worst case running time for one of these cases
may not be better than O(V 3).)

Solution: The algorithm should behave differently in these three cases: r =

wi,j . No changes are needed, since no shortest path can change.
2. r < wi,j .

In this case, we may improve the distances for some pairs of vertices: for
each pair (x, y) of vertices, x = y, set

dx,y = min(dx,i + r + dj,y, dx,y).

The two terms in the min expression are as follows:

• The first term is for the case where the new shortest path from x to y
contains the edge (i, j).

• The second term is for the case where the new shortest path from x to
y does not contain the edge (i, j), in which case the shortest path remains
unchanged.

Note that, in the first case, the values of dx,i and dj,y do not change as a
result of this adjustment, because the edge (i, j) cannot be included in a
shortest path from x to i or a shortest path from j to y.
The total time to recalculate D is O(V 2) (since we need to consider all
pairs of vertices i and j). The total extra space required is O(1). To adjust
the predecessor matrix Π, we need only consider matrix entries πx,y for
which we reduce the value of dx,y. For each of these, we consider two
cases:
if y = j, then πx,y = i, and otherwise πx,y = πj,y. Note that, in this second
case, πj,y does not change as a result of this adjustment, because (i, j)
does not appear in the shortest path from j to y. The total time to adjust
Π is O(V 2), and we need only O(1) extra space.
3. r > wi,j .
In this case, we may worsen the distances for some pairs of nodes.
Unfortunately, this seems to require recalculating best distances and
parents for all nodes from scratch. D and Π can be recalculated in time
O(V 3) using Floyd-Warshall.

(b) Give an example of a weighted directed graph G = (V, E, W), a

distance matrix D, and a triple (i, j, r) such that any algorithm that
modifies D to reflect the effects of changing wi,j to r must take Ω(V 2)
time. Solution: Let G be a line graph with n vertices 1, 2, . . . , n and
edges (i, i + 1) for all i. Suppose the weights for all these directed edges
are 1. All other weights are ∞. Let e = (n, 1, 1). Then for every i, j, i < j,
dj,i = ∞ before the modification, but is a positive integer after the
modification. That means that Ω(n2) entries of D must change.

Now suppose that we add a new constraint to the problem — an upper

bound of h on the number of hops (edges) in the paths we want to
consider. More formally, given a weighted digraph G = (V, E, W) and a
positive integer h, 0 ≤ h ≤ n − 1, we would like to produce a distance
matrix D giving the shortest distances for at-most-h-hop paths.

(c) Adapt the Floyd-Warshall algorithm to solve the bounded-hop APSP

problem. Analyze its complexity in terms of graph parameters and h.
Solution: The Floyd-Warshall algorithm introduces intermediate vertices
in order, one at a time, in |V | executions of an outer loop (see the
code on p. 695 of CLRS). Within each execution of this loop, it considers
all pairs (i, j) of vertex numbers. Each such pair requires time O(1)
because it involves examining and comparing only three entries in D.
When we add the constraint that the complete path must
consist of at most h hops,
the comparison on line 7 becomes more complicated. It must consider all
the different ways of allocating the h hops to the two parts of the path -
the part that comes before the new vertex k and the part that comes after
k. So, we define dk,h to be the weight i,j of a shortest path from vertex i to
vertex j for which all intermediate vertices are in the set 1, . . . , k with the
added constraint that the path consists of at most h hops. dk,h i,j can now
be expressed as,

The total number of sub-problems is now O(V 3·h), and the time
required to solve each sub-problem is O(h), which means the total
runtime of this algorithm is O(V 3 · h2). For the space requirement,
while calculating the results for k, we need distance information for k −
1 and all values of h, so the space complexity is now O(V 2 · h).

(d) Adapt the matrix multiplication strategy from Section 25.1 to solve
the bounded-hop APSP problem. Analyze its complexity in terms of
graph parameters and h. Try to get logarithmic dependence on h.

Solution: In the description in Section 25.1, the matrix L(k) contains

shortest distances using paths of at most k hops; specifically, l k is the
shortest distance for a i,j path from i to j consisting of at most k hops.
Thus, L(0) is the matrix with 0 on the main diagonal and ∞ everywhere
else, and for every k, L(k+1) = Lk · W, where the matrix multiplication
here uses min and + instead of the usual + and ×. Our goal is to
produce L(h) .

If h = 0 then the answer is simply the matrix with 0s on the main

diagonal and ∞ elsewhere. Now assume h ≥ 1.
We cannot use the successive squaring strategy from p. 689-690 directly,
because
that would “overshoot” h if it is not a power of 2. However, we can get the
logarithmic dependence on h by using its binary representation, h = hlhl−1
. . . h1. Since h ≥ 1, = L(1) = L(0) we have hl = 1. Start with L(hl) · W = W.
Then for j = l − 1, . . . , 1, calculate L(hl...hj ) as follows: If hj = 0 then
(L(hl) )2, else (L(hl) )2 · W. The final answer is L(hl...h1) .

The number of matrix calculations is O(lg h), and each calculation takes
time O(V 3), for a total time complexity of O(V 3 lg h). Note that this is
better than the modified Floyd-Warshall algorithm in Part (c), which is
interesting given that vanilla FloydWarshall performs better on the
standard All-pair Shortest Path problem. The space complexity is O(V 2).

(e) Finally, consider a dynamic version of the bounded-hop APSP

problem. Design an algorithm that is given the following as input:

1. a weighted directed graph G = (V, E, W);

2. a hop count h, 0 ≤ h ≤ n − 1;

3. a correct distance matrix D yielding shortest at-most-h-hop distances,

and possibly additional distance information that is useful for solving this
problem; and

4. a triple (i, j, r), where i, j ∈ V and r is a nonnegative real.

Your algorithm should modify D to reflect the effects of changing wi,j to r,
and should also update any additional distance information that you have
added. As for Part (a), your algorithm will need to handle three cases: r =
wi,j , r < wi,j , and r > wi,j . For each of the cases, analyze your algorithm’s
complexity, in terms of graph parameters and h.

Solution: The additional distance information might be the entire set of

matrices L(h) L(k) , 0 ≤ k ≤ h, as defined in the solution to Part (d). Thus,
D = . All of these can be calculated from scratch in time O(V 3 · h), using
a series of successive multiplications by matrix W.
Consider how to modify the solution to Part (a). The case where r = wi,j
still involves no changes, and the case where r > wi,j involves
recalculation of all the distances, in all the matrices, at a time cost of
O(V 3 · h).
In the case where r < wi,j , we must recalculate the distances for all
ordered pairs (x, y) in all of the matrices; thus, we must recalculate V 2 ·
h entries. For each x, y, we define the following:

The time cost for recalculating each entry is O(k), which is O(h). So the
total time cost is O(V 2 · h2). The space complexity is O(V 2 · h).

Problem 6-2. Minimum Spanning Trees with Unique Edge Weights

Consider an undirected graph G = (V, E) with a weight function w

providing nonnegative realvalued weights, such that the weights of all
the edges are different.
(a) Prove that, under the given uniqueness assumption,
(b) G has a unique
Minimum Spanning Tree.
Solution: Suppose for the sake of contradiction that G has two different
MSTs, T1 and T2. Let e be the smallest weight edge that appears in
exactly one of T1 and T2 - note that such an edge must exist since trees
T1 and T2 are distinct. Without loss of generality, suppose that e is in T1
and not in T2. Then form a new graph T2 0 consisting of T2 with e added.
Observe that T2 0 now has a cycle. Since T1 can’t contain the entire cycle,
there must be some edge e 0 = e in the cycle that is not in T1. Since we
assumed that e is the smallest weight edge in one of the trees and that e
0 is in T2 but not in T1, we see that w(e 0 ) > w(e). (We are using the
unique weight assumption here to get strict inequality.) Then removing e
0 from T2 0 yields a new spanning tree T2 00 with smaller weight than
T2. This contradicts our initial assumption that T2 is an MST.

Each of the next three parts outlines an MST algorithm for graphs with
unique edge weights. In each case, say whether this is a correct MST
algorithm or not. If so, give a proof, a more detailed description of an
efficient algorithm, and an analysis. If not, give a specific counterexample.
(We are omitting the point values for these parts because we will assign
more points to algorithms and fewer to counterexamples.)

(b) [Batched Edge-Addition MST]

The algorithm maintains a set A of edges that are known to be in the MST.
Initially, A is empty. The algorithm operates in phases; in each, it adds a
batch of one or more edges to A. Phases continue until we have a
spanning tree. Specifically, in each phase, the algorithm does the
following: For each component tree C in the forest formed by A, identify
the lightest weight edge eC crossing the cut between C and the rest of the
components. After determining these edges for all component trees, add
all of the edges eC to A, in one batch.
Solution: This does yield an MST.

We can show by induction on the number of phases that the set A is

always a subset of the unique MST. For the base case, the set A contains
no edges, which trivially is a subset of the unique MST.

For the inductive step, consider a set A of edges at the beginning of some
phase. By our inductive hypothesis, the set A is a subset of the unique
MST. We want to show that at the end of the same phase, the set A0
constructed by adding some edges to A, is still a subset of the unique MST.

For each component C in the forest formed by A, the lightest edge is part
of some MST, by CLRS Corollary 23.2. Since there is only one MST, all the
chosen edges are part of the same unique MST. Thus, when we add them
all, the new set A0 obtained at the end of the phase is still a subset of the
unique MST.

Detailed algorithm:

We can implement this algorithm using a Union-Find set structure for the
vertices. For each component in the structure, we maintain a list of edges
that have exactly one endpoint in the component. Initially, A is empty, and
we create a separate set for each vertex, using the MAKESET operation
described in Recitation 3. We sort the edges in ascending order of edge
weights in O(E log E) time. For each single-vertex component, we compute
an individual list of edges incident on that component. This can be done by
a linear pass through the sorted edge list.
At each phase, we perform the following steps,

• For each component C, we find the lightest incident edge, by looking at

the first entry in its edge list. This takes O(1) time. All these edges are added
to A.

• For each edge added to A, perform a union operation between the

components associated with the end points of the edge.

• Now, we need to update the edge list for each of the merged
components. This can be done using the two-finger algorithm from Merge
sort. Each of these edge lists has O(Ei) elements, so the merge step takes
O(Ei) time. (Here, we assume that component i has Ei edges, and WLOG, for
arbitrary components i and j, Ei > Ej ) During this merge step, we need to
remove all edges that now belong to the same component; this can be done
by calling FIND on each edge of the merged list - the total number of edges
in the merged list is O(Ei) and the time complexity of each FIND operation is
O(α(V ), which means that the total time complexity of this merge step is
O(Ei(1 + α(V ))).

Note that the worst case time complexity of the merge operation per
component per iteration is O(Ei(1 + α(V ))), leading to a worst case time
complexity per iteration of O( i Ei(1 + α(V ))) = O(E(1 + α(V ))). Also note that
the total number of iterations in the worst case is O(log V ) (since the
number of components is reduced by at least a factor of two at each
phase), leading to a total worst case time complexity of O(E log V (1 +
α(V ))).
The total length of all individual edge lists is O(E), and the space complexity
of the Union-Find data structure that keeps track of which component a
vertex belongs to is O(V ), which means that this algorithm has a total
space complexity of O(V + E), in addition to the list A, which has size O(E).

(c) [Divide-and-Conquer MST]

The algorithm uses a simple Divide-and-Conquer strategy: Divide the set V

of vertices arbitrarily into disjoint sets V1 and V2, each of size roughly V/2.
Define graph

G1 = (V1, E1), where E1 is the subset of E for which both endpoints are in
V1. Define

G2 = (V2, E2) analogously. Recursively find (unique) MSTs for both G1 and
G2; call them T1 and T2. Then find the (unique) lightest edge that crosses
the cut between the two sets of vertices V1 and V2, and add that to form
the final spanning tree T.

Solution: Incorrect. A simple counterexample is a four-node ring graph

with nodes a, b, c, d, and edge weights w(a, b) = 1, w(b, c) = 11, w(c, d) =
2, w(d, a) = 12.
The graph could be split with V1 = {a, d} and V2 = {b, c}. Then the MSTs of
the
two halves have weights 12 and 11 respectively. Adding in the lightest cut
edge (edge between a and b with weight 1) gives us a Spanning Tree of
weight 11 + 12 + 1 = 24, which is clearly sub-optimal (edges (a, b), (b, c)
and (c, d) yield a spanning tree of weight 14).

(d) [Cycle-Breaking MST]

The algorithm operates in phases. In each phase, the algorithm first finds
some nonempty subset of the simple cycles in the graph. Then it identifies
the heaviest edge on each cycle, and removes all these heavy edges.
Phases continue until we have a spanning tree.

Solution: This does yield an MST. Let T denote the unique MST of G. We
first state and prove the following claim. Claim: For each simple cycle C in
G, the heaviest edge on cycle C is not in T. Proof of

Claim: Suppose for the sake of contradiction that the heaviest edge of
some simple cycle C is in T.

Since T cannot contain the entire cycle C, there must be some other edge e
= e in C that is not in T. Then we can construct a new tree T from T by
adding edge e and removing edge e. T is also a spanning tree, and its
weight is strictly less than that of T, which is a contradiction, since we
assumed that T is the MST. End of proof of Claim Now consider any edge e
that is removed during any phase i of the algorithm. Edge e must be the
heaviest edge of some simple cycle C of the graph G at the beginning of
phase i. But cycle C is also a simple cycle of the original graph G, so the
removed edge e is also the heaviest edge on a simple cycle of G. So by the
Claim, edge e is not in T.
Thus, the algorithm only removes edges that are not in T. Since the final
graph is
a spanning tree, and contains T, it must be equal to T.

Detailed algorithm:

We can implement this algorithm as

follows, CYCLEBREAKINGMST(G)

1 while |G.E| > |V | − 1

2 C = FINDCYCLE(G).

3 e = FINDMAXIMUMEDGE(C)

4G=G−e

5 return G

Here, FINDCYCLE finds some cycle in the graph G and returns it - this can be
implemented using Depth First Search (DFS); DFS allows us to find back
edges within the graph G in O(E) time. Once we have a cycle, we can find
the maximum weight edge in it in O(V ) time (since a simple cycle can have
at most V edges); we then remove this edge from the graph G and repeat
the above steps on the reduced graph, until the graph contains no more
cycles.
The total runtime complexity of this algorithm is O(E · (E − V )) = O(E2)
time. The
total space complexity of the algorithm is O(E), since we only need to
keep track of one simple cycle in the graph, and a simple cycle in the
worst case has O(E) edges. Remark: Note that in the above
implementation, we remove one edge from the graph at a time. We can
often do better than this by removing multiple edges from the graph in a
single iteration (multiple cycles could be identified in a single iteration).
However, it is not clear how to improve the worst-case time complexity
by doing this.