Floyd-Warshall Algorithm#

Welcome to Day 46 of our 60 Days of Coding Algorithm Challenge! Today, we’ll explore the Floyd-Warshall algorithm, a powerful algorithm for finding the shortest paths between all pairs of vertices in a weighted graph.

What is the Floyd-Warshall Algorithm?#

The Floyd-Warshall algorithm is an algorithm for finding shortest paths in a weighted graph with positive or negative edge weights (but with no negative cycles). Unlike Dijkstra’s algorithm, which finds the shortest path from a single source to all other vertices, Floyd-Warshall finds the shortest paths between all pairs of vertices.

How Does It Work?#

The algorithm works by iteratively improving an estimate on the shortest path between two vertices, until the estimate is optimal. It does this by considering all possible intermediate vertices between each pair of vertices.

Implementing Floyd-Warshall Algorithm#

Here’s an implementation of the Floyd-Warshall algorithm:

 1def floyd_warshall(graph):
 2    n = len(graph)
 3    dist = [row[:] for row in graph]  # Create a copy of the graph
 4    
 5    # Initialize the distance matrix
 6    for i in range(n):
 7        for j in range(n):
 8            if i != j and dist[i][j] == 0:
 9                dist[i][j] = float('inf')
10    
11    # Main algorithm
12    for k in range(n):
13        for i in range(n):
14            for j in range(n):
15                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
16    
17    return dist
18
19# Example usage
20graph = [
21    [0, 5, float('inf'), 10],
22    [float('inf'), 0, 3, float('inf')],
23    [float('inf'), float('inf'), 0, 1],
24    [float('inf'), float('inf'), float('inf'), 0]
25]
26
27result = floyd_warshall(graph)
28for row in result:
29    print(row)

Time and Space Complexity#

• Time Complexity: O(V^3), where V is the number of vertices in the graph.
• Space Complexity: O(V^2) to store the distance matrix.

Detecting Negative Cycles#

The Floyd-Warshall algorithm can also be used to detect negative cycles in the graph. If after running the algorithm, any diagonal element in the distance matrix is negative, then there exists a negative cycle in the graph.

 1def has_negative_cycle(dist):
 2    n = len(dist)
 3    for i in range(n):
 4        if dist[i][i] < 0:
 5            return True
 6    return False
 7
 8# Check for negative cycles
 9if has_negative_cycle(result):
10    print("Graph contains a negative cycle")
11else:
12    print("No negative cycle detected")

Reconstructing Paths#

We can modify the algorithm to not only find the shortest distances but also reconstruct the paths:

 1def floyd_warshall_with_path(graph):
 2    n = len(graph)
 3    dist = [row[:] for row in graph]
 4    next = [[j if graph[i][j] != float('inf') else None for j in range(n)] for i in range(n)]
 5    
 6    for i in range(n):
 7        for j in range(n):
 8            if i != j and dist[i][j] == 0:
 9                dist[i][j] = float('inf')
10                next[i][j] = None
11    
12    for k in range(n):
13        for i in range(n):
14            for j in range(n):
15                if dist[i][k] + dist[k][j] < dist[i][j]:
16                    dist[i][j] = dist[i][k] + dist[k][j]
17                    next[i][j] = next[i][k]
18    
19    return dist, next
20
21def reconstruct_path(next, u, v):
22    if next[u][v] is None:
23        return []
24    path = [u]
25    while u != v:
26        u = next[u][v]
27        path.append(u)
28    return path
29
30# Example usage
31dist, next = floyd_warshall_with_path(graph)
32print("Shortest path from 0 to 3:", reconstruct_path(next, 0, 3))

Applications of Floyd-Warshall Algorithm#

1. Finding the shortest paths in a weighted graph
2. Inversion of real matrices
3. Fast computation of Pathfinder networks
4. Finding the transitive closure of a graph
5. Finding a regular expression denoting the regular language accepted by a finite automaton

Exercise#

1. Implement a version of the Floyd-Warshall algorithm that can handle graphs with no path between some pairs of vertices (represented by infinity).

2. Modify the algorithm to find the maximum flow between all pairs of vertices in a flow network.

3. Use the Floyd-Warshall algorithm to solve the “All-Pairs Shortest Path” problem for a real-world scenario, such as finding the shortest routes between all pairs of cities on a map.

Summary#

Today, we explored the Floyd-Warshall algorithm, a powerful method for finding shortest paths between all pairs of vertices in a weighted graph. We implemented the basic algorithm, added negative cycle detection, and showed how to reconstruct the actual paths.

The Floyd-Warshall algorithm is particularly useful when we need to find shortest paths between all pairs of vertices, or when the graph may contain negative edge weights (but no negative cycles).

Solution#

 1# Exercise 1: Floyd-Warshall that handles missing paths (infinity) cleanly.
 2# We keep unreachable pairs as float('inf') and never treat them as real edges.
 3def all_pairs_shortest(graph):
 4    n = len(graph)
 5    # Copy so we do not mutate the caller's matrix.
 6    dist = [row[:] for row in graph]
 7    for k in range(n):
 8        for i in range(n):
 9            # Skip when i cannot reach k, avoiding inf + inf arithmetic.
10            if dist[i][k] == float('inf'):
11                continue
12            for j in range(n):
13                if dist[k][j] == float('inf'):
14                    continue
15                if dist[i][k] + dist[k][j] < dist[i][j]:
16                    dist[i][j] = dist[i][k] + dist[k][j]
17    return dist
18
19INF = float('inf')
20graph = [
21    [0,   5,   INF, 10],
22    [INF, 0,   3,   INF],
23    [INF, INF, 0,   1],
24    [INF, INF, INF, 0],
25]
26for row in all_pairs_shortest(graph):
27    print(row)  # [0, 5, 8, 9], unreachable pairs stay INF