Floyd's Algorithm

The Floyd-Warshall algorithm in computer science is a method for locating the shortest paths in a directed weighted network with positive or negative edge weights (but no negative cycles). It is sometimes referred to as Floyd's algorithm, the Roy-Warshall algorithm, the Roy-Floyd algorithm, or the WFI algorithm. The algorithm will discover the lengths (summed weights) of shortest routes between all pairs of vertices in a single run. Although the algorithm does not return information about the paths themselves, it is still possible to reconstruct the paths. The approach may also be used to determine the largest pathways between all pairs of vertices in a weighted graph, or (in association with the Schulze voting system) the transitive closure of a relation R.

History and Naming

Robert Floyd first published the Floyd-Warshall method in 1962, and it is a prime example of dynamic programming. It is closely related to Kleene's algorithm (published in 1956) for converting a deterministic finite automaton into a regular expression, but it is basically the same as algorithms previously published by Bernard Roy in 1959 and also by Stephen Warshall in 1962 for finding the transitive closure of a graph. Peter Ingerman introduced the standard version of the method as three layered for-loops in 1962.

For resolving all pairings of shortest-path issues, use the Floyd Warshall algorithm. Finding the shortest distances between each pair of vertices in an edge-weighted directed graph is the goal of the task.

In a weighted network, it is an algorithm for determining the shortest path between every pair of vertices. The dynamic programming method is used by this algorithm to determine the shortest path.

Below is a C-function for an N x N graph. The function keeps track of the shortest path for every pair in the matrix cost [N][N]. The provided graph's cost matrix is accessible in cost Mat [N][N].

Floyd Warshall Algorithm:

• As a first step, initialize the solution matrix to be identical to the input graph matrix.
• The solution matrix is then updated by treating each vertex as an intermediate vertex.
• The plan is to select each vertex one at a time and update any shortest routes that use the selected vertex as an intermediate vertex.
• Vertices 0, 1, 2,.., k-1 are already taken into consideration when vertex number k is chosen as an intermediate vertex.
• There are two potential outcomes for every pair of source and destination vertices (i, j), respectively.
• The shortest path from i to j does not include k as an intermediary vertex. We maintain the current dist[i][j] value.
• k is an intermediate vertex in shortest path from i to j. We update the value of dist[i][j] as dist[i][k] + dist[k][j] if dist[i][j] > dist[i][k] + dist[k][j].
• The aforementioned optimum substructure property in the all-pairs shortest route issue is depicted in the following image.

Output

```The following matrix shows the shortest distances between every pair of vertices
0      5      8      9
INF      0      3      4
INF    INF      0      1
INF    INF    INF      0
................................................
Process executed in 1.11 seconds
Press any key to continue.
```

Explanation

The program mentioned above only outputs the shortest distances. By putting the preceding data in a separate 2D matrix, we may alter the approach to display the shortest pathways as well.

Additionally, INT_MAX from the limitations can be used as the value of INF.h to guarantee that we handle the highest value feasible. To prevent arithmetic overflow, we must modify the if condition in the program above when we take INF as INT_MAX.