The Floyd–warshall (abbreviated Floyd algorithm) is a wellknown algorithm for solving the shortest path between any two points (all Paris shortest paths,apsp). On the surface, the Floyd algorithm is a very simple triple loop, and the Pure Floyd algorithm loops inside the statement is very concise. In my opinion, it is precisely because "Floyd algorithm is a dynamic programming (dynamical programming) algorithm" nature, it leads to Floyd algorithm so exquisite. Therefore, here I will from the Floyd algorithm's state definition, the dynamic transfer equation and the rolling array and other important aspects, to simply analyze this important dynamic programming based algorithmfloyd algorithm.
In the dynamic programming algorithm, it is the definition of state that is in the first place and one of the core concepts. Here, D[k][i][j] is defined as:
The shortest path length between points I point J can only be used when the 1th to K point is the intermediate medium. ”
The graph has n points, numbering starting from 1 to N. Therefore, here, K can be considered as a dynamic programming algorithm at the time of the process of a level, or called "slack operation." D[1][I][J] Indicates the shortest path length between points I point J when using only 1th points as intermediate medium, and d[2][i][j] represents the shortest path length between points I to J when using all points in point 1th to point 2nd as intermediate Medium; D[n1][i][j] means using point 1th to When all points in the (n1) point are used as intermediaries, the shortest path length between points I point J d[n][i][j] represents the shortest path length between points I to point J when using the number 1th to n points. With the definition of the state, we can construct the dynamic transfer equation according to the dynamic programming idea.
The basic idea of dynamic transfer can be considered as a kind of transfer representation to establish a state and a former state . According to the previous definition, D[k][i][j] is a state using the number 1th to the K point, you can find a way to move the state through the dynamic, the statute to the use of 1th to (k1) status, that is D[k1][i][j]. For D[k][i][j] (i.e., the shortest path between I and J when using all points in the 1thtoK point as intermediate Medium), can be divided into two cases: (1) I to J Short circuit not through K, (2) I to J short circuit by K. D[K][I][J]=D[K1][I][J] without the shortest circuit of point K. After the shortest circuit of point K, D[k][i][j]=d[k1][i][k]+d[k1][k][j]. Therefore, the dynamic transfer equation of the Floyd algorithm can be obtained by combining the above two conditions:
D[k][i][j] = min (D[k1][i][j], d[k1][i][k]+d[k1][k][j]) (K,I,j∈[1,n])
Finally, D[n][i][j] is the length of the shortest path between all two points in the requested graph. Here, it is important to note the initial (boundary) condition of the dynamic transfer equation described above, i.e. d[0] [I][j]=w (i, J), that is, if no point is used (the initial of "slack operation"), the length of the shortest path between two points is the weight of the edge between two points (if there is no edge between two points, the , and I prefer to use the graph in the Floyd algorithm to represent the data structure of the adjacency matrix, because it is easy to operate. Of course, there are d[i][i]=0(i∈[1,n]).
So we can write the most preliminary Floyd algorithm code:
123456789101112 
void floyd_original() {
for
(
int i = 1; i <= n; i++)
for
(
int j = 1; j <= n; j++)
d[0][i][j] = graph[i][j];
for
(
int k = 1; k <= n; k++) {
for
(
int i = 1; i <= n; i++) {
for
(
int j = 1; j <= n; j++) {
d[k][i][j] = min(d[k1][i][j], d[k1][i][k] + d[k1][k][j]);
}
}
}
}

Almost all of the most famous "0/1 knapsack" problem in the dynamic planning algorithm books, will further introduce the use of rolling array techniques to further reduce the space complexity of the algorithm, so that the 0/1 backpack only need to use a onedimensional array to obtain the best solution. In all kinds of data, the most common Floyd algorithm uses a twodimensional array to represent the state. So, in the Floyd algorithm, how to use the scrolling array?
Observing the dynamic transfer equation D[k][i][j] = min (D[k1][i][j], d[k1][i][k]+d[k1][k][j]), you can find the state of each Kphase (D[k][i][j]), which depends on the previous stage (that is, the k1 order (e.g. D[k1][i][j],d[k1][i][k] and d[k1][k][j]).
The twodimensional matrix of the shortest path length between two points in the figure is described in the case of the first Floyd algorithm, which calculates the state d[k][i][j], d[k1][][] and d[k][][] (d[k1][][) for the k1 stage. d[k][][ ] represents the twodimensional matrix of the shortest path length between two points in the figure of phase K. A directed line segment with arrows in red indicates the planning direction. Gray represents an array element that has already been counted, and white represents an element that has not yet been counted. Because d[k1][][] and d[k][][] are two independent twodimensional arrays, there is no problem using d[k1][i][j],d[k1][i][k] and D[k1][k][j] (both in the twodimensional array above) to calculate d[k] [i][j].
So how do you use a twodimensional array to implement a scrolling array to reduce the complexity of space?
Is the case when using a scrolling array, in phase K, to calculate d[i][j]. At this point, because the twodimensional array using d[][] is used as a scrolling array, it is reused in each phase of the calculation, so that dimension of the representation phase in the array is also canceled. In this figure, the white lattice represents the newest calculated element (the new value of the Kstage), and the value of the element in the gray lattice is actually saved as the old value of the previous stage (that is, the k1 phase). Therefore, when the new D[i][j] has not been computed, the value saved in D[i][j] actually corresponds to the value d[k1][i][j] when the scroll array was not used previously. At this point, the dynamic transfer equation becomes after the hidden phase index:
D[i][j] = min (D[i][j], d[i][k]+d[k][j]) (k,I,j∈[1,n])
Assignment number to the left D[i][j] is the shortest path length between I and J, which is the k phase we are going to calculate. Here, you need to make sure that the value of d[i][j], d[i][k] and d[k][j] on the right of the assignment is the value of the previous stage (K1 stage). Before the new D[i][j] is calculated, the value reserved by the D[i][j] element is indeed the old value of the previous stage. But as for d[i][k] and D[k][j]? We cannot determine whether the two elements fall in the white area (the new value) or the gray area (the old value). Fortunately there is such an important nature that dp[k1][i][k] and dp[k1][k][j] will not change in the size of phase K. In other words, the value of the Kphase will not change if the side is connected to the Knode. How to prove it simply? We can put j=k into the previous d[k][i][j]=min (D[k1][i][j], d[k1][i][k]+d[k1][k][j]) equation, namely:
D[K][I][K]
= Min (D[k1][i][k], d[k1][i][k]+d[k1][k][k])
= Min (d[k1][i][k], d[k1][i][k]+0)
= D[k1][i][k]
That is to say, the shortest path length between point I and point k is constant in phase k1 and phase K. The same can be proved that in these two stages, the shortest path length between point K and Point J is constant. Therefore, for the transfer equation using the scrolling array d[i][j] = min (D[i][j], d[i][k]+d[k][j]), the values of d[i][j], D[i][k], and d[k][j] to the right of the assignment number are the values of the previous stage (the k1 phase). Can be used with confidence to calculate the value of d[i][j] at phase K.
The code for the Floyd algorithm that is rewritten with the scrolling array is as follows:
123456 
void floyd() {
for
(
int k = 1; k <= n; k++)
for
(
int i = 1; i <= n; i++)
for
(
int j = 1; j <= n; j++)
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

Therefore, through the analysis of this article, we can find that the Floyd algorithm is indeed a typical dynamic programming algorithm, understanding the Floyd algorithm can also help us to further understand the dynamic planning ideas.
Reprint: http://www.cnblogs.com/chenying99/p/3932877.html
Exploring the dynamic programming nature of Floyd algorithm