Floyd Warshall All Pairs Shortest Path in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the distance matrix with the given graph.

DSA Python

dist = [[[1] if i != j else 0 for j in range(V)] for i in range(V)]

Drag options to blanks, or click blank then click option'

A-1

B0

C1

Dfloat('inf')

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 for all distances, which incorrectly assumes all nodes are connected.

Using -1 which can cause wrong calculations in shortest path.

We use float('inf') to represent no direct edge between nodes, and 0 for the same node distance.

2fill in blank

medium

Complete the code to update the distance matrix with the direct edges from the graph.

DSA Python

for u, v, w in edges:
    dist[u][v] = [1]

Drag options to blanks, or click blank then click option'

A0

B1

Cw

Dfloat('inf')

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning 0 instead of the actual edge weight.

Assigning infinity which means no edge.

We assign the weight w of the edge from u to v to the distance matrix.

3fill in blank

hard

Fix the error in the Floyd Warshall update condition to correctly check for shorter paths.

DSA Python

if dist[i][k] != float('inf') and dist[k][j] != float('inf') and dist[i][k] + dist[k][j] [1] dist[i][j]:
    dist[i][j] = dist[i][k] + dist[k][j]

Drag options to blanks, or click blank then click option'

A>=

B<

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using > which would update only if new path is longer.

Using == which does not update for shorter paths.

We update dist[i][j] only if the new path through k is shorter (less) than the current distance.

4fill in blank

hard

Fill both blanks to complete the nested loops for Floyd Warshall algorithm.

DSA Python

for [1] in range(V):
    for [2] in range(V):
        # update distances

Drag options to blanks, or click blank then click option'

Ak

Bi

Cj

Dv

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable names that confuse the roles of loops.

Mixing up the order of loops.

The outer loop uses k as the intermediate node, inner loop uses i as the start node.

5fill in blank

hard

Fill all three blanks to complete the triple nested loops for Floyd Warshall algorithm.

DSA Python

for [1] in range(V):
    for [2] in range(V):
        for [3] in range(V):
            if dist[[2]][[1]] != float('inf') and dist[[1]][[3]] != float('inf') and dist[[2]][[1]] + dist[[1]][[3]] < dist[[2]][[3]]:
                dist[[2]][[3]] = dist[[2]][[1]] + dist[[1]][[3]]

Drag options to blanks, or click blank then click option'

Ak

Bi

Cj

Dm

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect loop variable names.

Mixing the order of loops.

The loops are for k (intermediate), i (start), and j (end) nodes respectively.

Practice

1. What is the main purpose of the Floyd Warshall algorithm in graph theory?

easy

A. To find the shortest paths between all pairs of vertices in a weighted graph

B. To find the minimum spanning tree of a graph

C. To perform a depth-first search traversal

D. To detect cycles in a graph

Solution

1. Step 1: Understand Floyd Warshall's goal

   The Floyd Warshall algorithm calculates shortest paths between every pair of vertices in a weighted graph.

2. Step 2: Compare with other graph algorithms

   Minimum spanning tree, DFS, and cycle detection serve different purposes than Floyd Warshall.

3. Final Answer:

   To find the shortest paths between all pairs of vertices in a weighted graph -> Option A

4. Quick Check:

   Floyd Warshall = all pairs shortest paths [OK]

Hint: Floyd Warshall finds shortest paths between all vertex pairs [OK]

Common Mistakes:

• Confusing with minimum spanning tree algorithms
• Thinking it finds shortest path from one source only
• Mixing with traversal algorithms like DFS or BFS

2. Which of the following is the correct way to initialize the distance matrix dist for Floyd Warshall in Python for a graph with n vertices?

easy

A. dist = [[0] * n] * n

B. dist = [[float('inf')] * n for _ in range(n)]

C. dist = [float('inf')] * n * n

D. dist = [0 for _ in range(n)]

Solution

1. Step 1: Understand matrix initialization

   We need a 2D list with size n x n, each element set to infinity initially.

2. Step 2: Check each option

   dist = [[float('inf')] * n for _ in range(n)] correctly creates a new list for each row with float('inf'). dist = [float('inf')] * n * n creates a 1D list, not 2D. dist = [[0] * n] * n creates shallow copies causing aliasing. dist = [0 for _ in range(n)] creates 1D list.

3. Final Answer:

   dist = [[float('inf')] * n for _ in range(n)] -> Option B

4. Quick Check:

   2D list with inf values = dist = [[float('inf')] * n for _ in range(n)] [OK]

Hint: Use list comprehension for 2D matrix initialization [OK]

Common Mistakes:

• Using multiplication for 2D lists causing shared references
• Creating 1D list instead of 2D
• Initializing with zeros instead of infinity

3. What will be the output distance matrix after running Floyd Warshall on this graph represented by adjacency matrix?

graph = [
  [0, 3, float('inf'), 7],
  [8, 0, 2, float('inf')],
  [5, float('inf'), 0, 1],
  [2, float('inf'), float('inf'), 0]
]

medium

A. [[0, 3, 5, 6], [5, 0, 2, 3], [3, 6, 0, 1], [2, 5, 7, 0]]

B. [[0, 3, 10, 7], [8, 0, 2, 3], [5, 8, 0, 1], [2, 5, 7, 0]]

C. [[0, 3, 7, 7], [8, 0, 2, 3], [5, 8, 0, 1], [2, 5, 7, 0]]

D. [[0, 3, 5, 7], [8, 0, 2, 3], [5, 8, 0, 1], [2, 5, 7, 0]]

Solution

1. Step 1: Initialize dist matrix same as graph

   Start with dist = graph matrix, where float('inf') means no direct edge.

2. Step 2: Update distances using Floyd Warshall logic

   Iterate k from 0 to 3, update dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]) for all i,j. After all iterations, shortest paths are computed.

3. Final Answer:

   [[0, 3, 5, 6], [5, 0, 2, 3], [3, 6, 0, 1], [2, 5, 7, 0]] -> Option A

4. Quick Check:

   All pairs shortest paths matrix = [[0, 3, 5, 6], [5, 0, 2, 3], [3, 6, 0, 1], [2, 5, 7, 0]] [OK]

Hint: Update dist with min of current and via intermediate vertex [OK]

Common Mistakes:

• Not updating distances through intermediate vertices
• Confusing indices in nested loops
• Leaving float('inf') where shorter paths exist

4. Consider this snippet of Floyd Warshall implementation in Python:

for k in range(n):
    for i in range(n):
        for j in range(n):
            if dist[i][k] + dist[k][j] < dist[i][j]:
                dist[i][j] = dist[i][k] + dist[k][j]

What is the main bug if dist[i][k] or dist[k][j] is float('inf')?

medium

A. It causes incorrect updates because adding infinity is not handled

B. It causes incorrect addition leading to overflow errors

C. No bug, the code works fine with infinity values

D. It causes syntax errors due to float('inf') usage

Solution

1. Step 1: Understand addition with infinity in Python

   float('inf') + any finite number = float('inf'), and float('inf') + float('inf') = float('inf').

2. Step 2: Check the condition

   The condition if dist[i][k] + dist[k][j] < dist[i][j] will be False whenever the sum is inf, because inf is not less than any finite or inf value. Thus, no incorrect updates occur; invalid paths are correctly skipped.

3. Final Answer:

   No bug, the code works fine with infinity values -> Option C

4. Quick Check:

   inf + x = inf, inf < y always False for path updates [OK]

Hint: Python's float('inf') handles additions and comparisons correctly for FW [OK]

Common Mistakes:

• Believing inf causes incorrect updates
• Confusing with integer overflow issues
• Thinking syntax error with inf

5. Given a graph with negative edge weights but no negative cycles, how does Floyd Warshall algorithm handle these edges to find shortest paths?

hard

A. It requires a separate algorithm to preprocess negative edges before running

B. It fails because it cannot handle negative weights at all

C. It ignores negative edges and only uses positive weights

D. It updates distances by considering intermediate vertices, correctly handling negative edges without cycles

Solution

1. Step 1: Understand Floyd Warshall with negative edges

   The algorithm can handle negative edges by updating distances through intermediate vertices, as long as no negative cycles exist.

2. Step 2: Confirm no negative cycle condition

   If negative cycles exist, shortest paths are undefined. Without them, Floyd Warshall converges to correct shortest paths.

3. Final Answer:

   It updates distances by considering intermediate vertices, correctly handling negative edges without cycles -> Option D

4. Quick Check:

   Negative edges allowed if no negative cycles [OK]

Hint: Floyd Warshall handles negative edges if no negative cycles exist [OK]

Common Mistakes:

• Thinking Floyd Warshall cannot handle any negative edges
• Confusing negative edges with negative cycles
• Assuming preprocessing is always needed