Floyd algorithm

Algorithm

The Floyed algorithm is an algorithm for efficiently and simultaneously finding the shortest paths betweeen every pair of vertices in a weighted and potentially directed graph.

Consider a graph G with vertices V,each numbered 1 through N. Further consider a function shortestPath(i,j,k) that return the shortest possible path from i to j using vertices only from the set {1,2,....k}  as intermediate point along the way. Now ,given this function ,our goal is to find the  shorttest  path from each i to each j using only vertices 1 to k+1.And the fuction what we want is called Floyed algorithm.

For each of these pairs of  vertices,the true shortest path could be either (1) a path that only uses vertices in the set {1,....,k} or (2) a path that goes from i to k+1 and then from k+1 to j.We know that the best path from i to j that uses vertices 1 through k is defined by shortestPath(i,j,k),and it is clear that if there were a better path from i to k+1 to j,then the length of this path would be  the concatenation of the shortest path from i to k+1(uing vertices in {1,....,k} and shortest path from k+1 to  j (also using vertices in {1,...,k}).

If w(i,j) is the weight of the edge between vertices i and j,we can define shortestPath(i,j,k) in terms of the following recursive  formula :the base case is

shortestPath(i,j,0)=w(i,j)

and the recursive case is

shortestPath(i,j,k)=min(shortestPath(i,j,k-1),shortestPath(i,k,k-1)+shortestPath(k,j,k-1)):

This formula is the heart of the Floyed algorithm. The algorithm works by first computer shortestPath(i,j,k) for all (i,j) pairs for k=1,then k=2,etc.This process continue until k=n,and we have found the shortest path for all (i,j) pairs using any intermediate vertices.

code :

 1 procedure FloydWarshallWithPathReconstruction ()
 2    for k := 1 to n
 3       for i := 1 to n
 4          for j := 1 to n
 5             if path[i][k] + path[k][j] < path[i][j] then {
 6                path[i][j] := path[i][k]+path[k][j];
 7                next[i][j] := k; }
 8
 9 function Path (i,j)
10    if path[i][j] equals infinity then
11      return "no path";
12    int intermediate := next[i][j];
13    if intermediate equals 'null' then
14      return " ";   /* there is an edge from i to j, with no vertices between */
15    else
16      return Path(i,intermediate) + intermediate + Path(intermediate,j);

Applications and generalizations

The Floyd–Warshall algorithm can be used to solve the following problems, among others:

• Shortest paths in directed graphs (Floyd's algorithm).
• Transitive closure of directed graphs (Warshall's algorithm). In Warshall's original formulation of the algorithm, the graph is unweighted and represented by a Boolean adjacency matrix. Then the addition operation is replaced by logical conjunction (AND) and the minimum operation by logical disjunction (OR).
• Finding a regular expression denoting the regular language accepted by a finite automaton (Kleene's algorithm)
• Inversion of real matrices (Gauss–Jordan algorithm) ^[3]
• Optimal routing. In this application one is interested in finding the path with the maximum flow between two vertices. This means that, rather than taking minima as in the pseudocode above, one instead takes maxima. The edge weights represent fixed constraints on flow. Path weights represent bottlenecks; so the addition operation above is replaced by the minimum operation.
• Testing whether an undirected graph is bipartite.
• Fast computation of Pathfinder networks.
• Widest paths/Maximum bandwidth paths

Case problem:

Now ,give you a problem and use the Floyd algorithm to slove it.Maybe it's helpful for you further understanding the algorithm!

http://www.cnblogs.com/heat-man/articles/2743401.html

Refefience:

http://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm