# Getting Started With Floyd’s Warshall Algorithm

Floyd’s Warshall Algorithm

• Floyd’s algorithm is used to find the shortest path between every pair of vertices of a graph. The algorithm works for both directed and un-directed, graphs.
• The graph may contain negative edges, but it may not contain any negative cycles.
• It requires weighted graphs.
• It computes the distance matrix of a weighted graph with ‘n’ vertices through a series of ‘nxn’ matrices.

D^0, D^1, D^2 . . . . . . . . . . . D^k-1 , . . . . , D^n
• In each matrix, Dk is the shortest distance and ‘Dij’ has to be computed between vertex (Vi and Vj).
• In particular, the series starts with D0 with no intermediate vertex. This means D0 is a matrix in which (Vi and Vj) that is (ith row and Jth Column) contains the weights are given by direct edges.
• In D1 matrix, the shortest distance going through one intermediate vertex with maximum path length of 2 edges are given.
• Continuing in this fashion, we will compute Dn, which contains the lengths of the shortest path among all the paths that can use all ‘n’ vertices as intermediate.

Example based on Floyd’s Warshall

From the graph, you just have to calculate the weight for moving one node to other node, like if you want to go to node 1 - -> node 2 then the cost is –> 8. To move to node 3 to node 1, you can see there is no direct path available for node 3 - -> node 1, so you have to take intermediate node. In our case, node 2 will become our intermediate node. The cost of moving node 3 - -> node 1 is - -> 3 (1+2) -> {cost of moving node3 -> node2 + node2 node1}.

First,we compute the -- > D0

D1 1 is an intermediate node.

D2 2 is an intermediate node.

D3 3 is an intermediate node.

The last D3 is your distance matrix, which purely gives you the shortest distance between the nodes.

Algorithm of Floyd’s Warshall

Input: The weighted matrix wt[1…n, 1….n,] for given graph.

Output

The Distance matrix D contains the shortest paths.

1. D0 -> W // Initialize the D array to w[]
2. P - -> 0 // Initialize the P array to 
3. for k -> 1 to n do
4. for i -> 1 to n do
5. for j -> 1 to n
6. if (Dk-1[ i, j ] > Dk-1 [ i, k ] + Dk-1 [ k, j ] )
7. then Dk[ i, j ] <-- Dk-1 [ i, k ] + Dk-1 [ k, j ]
8. P[ i, j ] <-- k;
9. else Dk[ i, j ] <-- Dk-1 [ i, j ]

Analysis of algorithm

D[i, j] min {D[I, j ], D[I, k] + D[K, j]}

Now, this operation is in three nested loops and can therefore be written, as shown below.

C (n) =
C (n) =
C (n) = :- [ = ½ n2 ]
From that,
C (n) = [ = 1/3 n3 ]

Therefore, Time Complexity of Floyd’s algorithm is – big O(n^3).

Implementation of Floyd’s Algorithm in C#

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5.
6. namespace Floyds_Warshall_Algorithm {
7.     class Program {
8.
9.         public
10.         const int INF = 10000;
11.
12.         private static void disp(int[, ] distance, int verticesCount) {
13.             Console.WriteLine("Distance Matrix for Shortest Distance between the nodes");
14.             Console.Write("\n");
15.
16.             for (int i = 0; i < verticesCount; ++i) {
17.                 for (int j = 0; j < verticesCount; ++j) {
18.                     // IF THE DISTANCE TO THE NODE IS NOT DIRECTED THAN THE COST IN iNIFINITY
19.
20.                     if (distance[i, j] == INF)
22.                     else
24.                 }
25.
26.                 Console.WriteLine();
27.             }
28.         }
29.
30.         public static void FloydWarshall(int[, ] graph, int verticesCount) {
31.             int[, ] distance = new int[verticesCount, verticesCount];
32.
33.             for (int i = 0; i < verticesCount; ++i)
34.                 for (int j = 0; j < verticesCount; ++j)
35.                     distance[i, j] = graph[i, j];
36.
37.             for (int k = 0; k < verticesCount; k++) {
38.                 for (int i = 0; i < verticesCount; i++) {
39.                     for (int j = 0; j < verticesCount; j++) {
40.                         if (distance[i, k] + distance[k, j] < distance[i, j])
41.                             distance[i, j] = distance[i, k] + distance[k, j];
42.                     }
43.                 }
44.             }
45.
46.             disp(distance, verticesCount);
48.
49.         }
50.
51.         static void Main(string[] args) {
52.             //inital Graph Given = D^0
53.
54.             int[, ] graph = {
55.
56.                 {
57.                     0,
58.                     8,
59.                     5
60.                 },
61.                 {
62.                     2,
63.                     0,
64.                     INF
65.                 },
66.                 {
67.                     INF,
68.                     1,
69.                     0
70.                 },
71.
72.             };
73.
74.             FloydWarshall(graph, 3);
75.
76.         }
77.
78.     }
79.
80. // This is just a sample script. Paste your real code (javascript or HTML) here.
81.
82. if ('this_is' == /an_example/) {
83.     of_beautifier();
84. else {
85.     var a = b ? (c % d) : e[f];
86. }
Input Graph

Here, you had provided one input graph, which is directed and weighted graph as per the requirement of Floyd’s algorithm. From here, it will move to Floydwarshall method to analyze it.

Here, it will check whether the source node and destination node are connected or not. If it is connected then it will find the minimum shortest path from all the intermediate nodes but one step at a time.

Output Window

This is the last distance matrix graph, where you can see it moving from any node to any node and you will get the minimum shortest path.

Thank you for reading! I hope you liked it.