Floyd Warshall All Pairs Shortest Path in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main purpose of the Floyd Warshall algorithm?

It finds the shortest paths between all pairs of nodes in a weighted graph, including graphs with negative edge weights but no negative cycles.

beginner

What is the time complexity of the Floyd Warshall algorithm?

The time complexity is O(V³), where V is the number of vertices in the graph.

intermediate

In Floyd Warshall, what does the matrix entry dist[i][j] represent during the algorithm?

It represents the shortest known distance from node i to node j considering intermediate nodes up to a certain point in the algorithm.

intermediate

Why can Floyd Warshall handle negative edge weights but not negative cycles?

Because it updates shortest paths by checking intermediate nodes, but if a negative cycle exists, the shortest path can decrease indefinitely, making the problem unsolvable.

intermediate

What is the key idea behind the Floyd Warshall algorithm's approach to finding shortest paths?

It uses dynamic programming by gradually allowing paths through intermediate nodes, updating shortest distances step-by-step for all pairs.

What does the Floyd Warshall algorithm compute?

A Minimum spanning tree

B Shortest path from a single source to all nodes

C Shortest paths between all pairs of nodes

D Topological sort of nodes

Floyd Warshall finds shortest paths between every pair of nodes in the graph.

Which of these is a requirement for Floyd Warshall to work correctly?

A No negative weight cycles

B Graph must be a tree

C No negative weight edges

D Graph must be directed acyclic

Floyd Warshall can handle negative edges but not negative cycles.

What is the main data structure used in Floyd Warshall to store distances?

A Adjacency list

B Distance matrix

C Queue

D Stack

A matrix stores shortest distances between all pairs of nodes.

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

A O(V²)

B O(E + V)

C O(V log V)

D O(V³)

The algorithm uses three nested loops over vertices, resulting in O(V³) time.

Which step is repeated in Floyd Warshall to update shortest paths?

A Check if going through an intermediate node improves path

B Relax edges from a single source

C Remove edges with negative weights

D Sort nodes by distance

The algorithm checks if using an intermediate node k improves the path from i to j.

Explain how the Floyd Warshall algorithm updates the shortest path distances using intermediate nodes.

Think about how the algorithm tries paths through each node as a middle step.

Describe the limitations of the Floyd Warshall algorithm and when it should not be used.

Consider graph size and presence of negative cycles.

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