Floyd Warshall All Pairs Shortest Path in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Floyd Warshall on a simple graph

What is the output distance matrix after running Floyd Warshall on this graph?

Graph edges with weights:
0 -> 1 (3), 0 -> 2 (8), 1 -> 2 (2), 2 -> 3 (1), 3 -> 0 (4)

Initial distance matrix (use 999 for infinity):
[[0, 3, 8, 999], [999, 0, 2, 999], [999, 999, 0, 1], [4, 999, 999, 0]]

DSA Python

def floyd_warshall(dist):
    n = len(dist)
    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]
    return dist

initial_dist = [
    [0, 3, 8, 999],
    [999, 0, 2, 999],
    [999, 999, 0, 1],
    [4, 999, 999, 0]
]
result = floyd_warshall(initial_dist)
print(result)

A [[0, 3, 5, 7], [7, 0, 2, 3], [5, 8, 0, 1], [4, 7, 9, 0]]

B [[0, 3, 5, 6], [999, 0, 2, 3], [999, 999, 0, 1], [4, 999, 999, 0]]

C [[0, 3, 8, 9], [999, 0, 2, 3], [999, 999, 0, 1], [4, 7, 9, 0]]

D [[0, 3, 5, 6], [7, 0, 2, 3], [5, 8, 0, 1], [4, 7, 9, 0]]

💡 Hint

Check if going through intermediate nodes reduces the path cost.

The Floyd Warshall algorithm updates the distance matrix by checking if going through an intermediate node k reduces the distance from i to j. After processing all nodes, the shortest paths are found. Option D shows the correct updated matrix.

🧠 Conceptual

intermediate

Understanding Floyd Warshall's time complexity

What is the time complexity of the Floyd Warshall algorithm for a graph with n vertices?

A O(n^3)

B O(n^2)

C O(n!)

D O(n log n)

💡 Hint

Think about the three nested loops over vertices.

Floyd Warshall uses three nested loops each running n times, resulting in O(n^3) time complexity.

🔧 Debug

advanced

Identify the error in Floyd Warshall implementation

What error will this code produce when run?

Code snippet:
dist = [[0, 1], [999, 0]] for k in range(len(dist)): for i in range(len(dist)): for j in range(len(dist)): if dist[i][k] + dist[k][j] < dist[i][j]: dist[i][j] = dist[i][k] + dist[k][j] print(dist)

DSA Python

dist = [[0, 1], [999, 0]]
for k in range(len(dist)):
    for i in range(len(dist)):
        for j in range(len(dist)):
            if dist[i][k] + dist[k][j] < dist[i][j]:
                dist[i][j] = dist[i][k] + dist[k][j]
print(dist)

A IndexError due to out of range access

B No error, prints [[0, 1], [999, 0]]

C TypeError due to adding int and list

D No error, prints [[0, 1], [1000, 0]]

💡 Hint

Check the indices and data types carefully.

The code runs correctly and updates no distances because no shorter path is found. The output remains [[0, 1], [999, 0]].

❓ Predict Output

advanced

Detecting negative cycles with Floyd Warshall

After running Floyd Warshall on a graph, how can you detect if there is a negative weight cycle?

DSA Python

def has_negative_cycle(dist):
    n = len(dist)
    for i in range(n):
        if dist[i][i] < 0:
            return True
    return False

A If any dist[i][i] < 0, there is a negative cycle

B If any dist[i][j] == 0 for i != j, there is a negative cycle

C If all dist[i][j] are positive, there is a negative cycle

D If dist[i][j] > dist[j][i] for some i,j, there is a negative cycle

💡 Hint

Check the diagonal elements of the distance matrix.

A negative cycle causes the distance from a node to itself to become negative after Floyd Warshall completes.

🚀 Application

expert

Using Floyd Warshall to find shortest path count

Given a graph with edges and weights, how can Floyd Warshall be adapted to also count the number of shortest paths between each pair of vertices?

A Modify Floyd Warshall to store predecessors only; count paths by traversing predecessors

B Use Floyd Warshall as is; count paths by backtracking after completion

C Maintain a separate matrix counting paths; update counts when a shorter path is found or equal path found

D Run Dijkstra from each vertex instead; Floyd Warshall cannot count paths

💡 Hint

Think about updating path counts when distances improve or tie.

To count shortest paths, maintain a count matrix. When a shorter path is found, reset count; when equal path found, add counts. This requires modifying Floyd Warshall.

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