楔子
long long ago就已经知道了Floyd算法，关键代码就4行，也容易记住，上上周又看到了Floyd，都说是动态规划，所以特意去学了一圈动态规划，今天终于又回到了它
状态方程：
d[k][i][j]定义：“只能使用第1号到第k号点作为中间媒介时，点i到点j之间的最短路径长度。”
在动态规划算法中，处于首要位置、且也是核心理念之一的就是状态的定义
这个大家喜欢把它叫做“松弛操作”，也就是relax
对于d[k][i][j]（即使用1号到k号点中的所有点作为中间媒介时，i和j之间的最短路径），可以分为两种情况:
1）i到j的最短路不经过k；（
2）i到j的最短路经过了k。不经过点k的最短路情况下，d[k][i][j]=d[k-1][i][j]。经过点k的最短路情况下，d[k][i][j]=d[k-1][i][k]+d[k-1][k][j]。
因此，综合上述两种情况，便可以得到Floyd算法的动态转移方程：
d[k][i][j] = min(d[k-1][i][j], d[k-1][i][k]+d[k-1][k][j])（k,i,j∈[1,n]）
初始条件：d[0][i][j]=w(i, j)，d[k][0][j]=0,d[k][i][0]=0
原始的实现如下：
# d[k][i][j] = min(d[k-1][i][j], d[k-1][i][k]+d[k-1][k][j])（k,i,j∈[1,n]）
import numpy as np
def floyd_original(graph):
vertex_num = len(graph)
list = np.full((vertex_num+1,vertex_num+1,vertex_num+1),np.inf)
list[:,0,:] = 0
list[:,:,0] = 0
for i in range(1,vertex_num+1):
for j in range(1,vertex_num+1):
list[0,i,j] = graph[i-1,j-1]
for k in range(1,vertex_num+1):
for i in range(1,vertex_num+1):
for j in range(1,vertex_num+1):
list[k,i,j] = min(list[k-1,i,j],list[k-1,i,k]+list[k-1,k,j])
return list[vertex_num,1:,1:]
观察DP数组，可以做空间优化，类似于背包问题使用滚动数组优化：
1、d[k][i][j]只与d[k-1][i][j], d[k-1][i][k]+d[k-1][k][j]有关，也就是只和d[k-1]，那么我们就可以只用一个二维数组代替三维的数组；
2、然后看我们是否需要注意遍历这个二维数组的顺序（例如01背包问题需要逆序遍历才能保证用的数据是上一层的，完全背包需要顺序遍历才能保证用的数据是更新后的这一层的），假如采取顺序的话，d[k-1][i][j]这个没问题，d[k-1][i][k]+d[k-1][k][j]这个k永远是小于或者等于i的，所以d[k-1][i][k]+d[k-1][k][j]取的是应该是更新后的数据，他们在已更新的区域里，那不是不能使用滚动数组了？但是事实已经证明可以这么用，后来发现一个解释：
3、有这样一条重要的性质，dp[k-1][i][k]和dp[k-1][k][j]是不会在第k阶段改变大小的。也就是说，凡是和k节点相连的边，在第k阶段的值都不会变。如何简单证明呢？我们可以把j=k代入之前的d[k][i][j]=min(d[k-1][i][j], d[k-1][i][k]+d[k-1][k][j])方程中，即：
d[k][i][k]
= min(d[k-1][i][k], d[k-1][i][k]+d[k-1][k][k])
= min(d[k-1][i][k], d[k-1][i][k]+0)
= d[k-1][i][k]
也就是说在第k-1阶段和第k阶段，点i和点k之间的最短路径长度是不变的。相同可以证明，在这两个阶段中，点k和点j之间的的最短路径长度也是不变的。因此，对于使用滚动数组的转移方程d[i][j] = min(d[i][j], d[i][k]+d[k][j])来说，赋值号右侧的d[i][j], d[i][k]和d[k][j]的值都是上一阶段（k-1阶段）的值，可以放心地被用来计算第k阶段时d[i][j]的值。
有没有很坑? 绕了一圈又回到不熟悉的东西上去了
仔细看一遍上述的公式就懂了。
所以我们可以使用滚动数组来优化空间。
实现如下：
import numpy as np
def floyd(graph):
vertex_num = len(graph)
list = np.zeros((vertex_num+1,vertex_num+1))
for i in range(1,vertex_num+1):
for j in range(1,vertex_num+1):
list[i,j] = graph[i-1,j-1]
for k in range(1,vertex_num+1):
for i in range(1,vertex_num+1):
for j in range(1,vertex_num+1):
list[i,j] = min(list[i,j],list[i,k]+list[k,j])
return list[1:,1:]
运行结果
#%%
graph = np.full((7,7),np.inf)
graph[0,:3] = [0,1,2]
graph[1,:4] = [1,0,3,4]
graph[2,:4] = [2,3,0,6]
graph[3,1:5] = [4,6,0,7]
graph[4,3:6] = [7,0,9]
graph[5,4:7] = [9,0,10]
graph[6,5:7] = [10,0]
print floyd_original(graph)
print floyd(graph)
[[ 0. 1. 2. 5. 12. 21. 31.]
[ 1. 0. 3. 4. 11. 20. 30.]
[ 2. 3. 0. 6. 13. 22. 32.]
[ 5. 4. 6. 0. 7. 16. 26.]
[12. 11. 13. 7. 0. 9. 19.]
[21. 20. 22. 16. 9. 0. 10.]
[31. 30. 32. 26. 19. 10. 0.]]
[[ 0. 1. 2. 5. 12. 21. 31.]
[ 1. 0. 3. 4. 11. 20. 30.]
[ 2. 3. 0. 6. 13. 22. 32.]
[ 5. 4. 6. 0. 7. 16. 26.]
[12. 11. 13. 7. 0. 9. 19.]
[21. 20. 22. 16. 9. 0. 10.]
[31. 30. 32. 26. 19. 10. 0.]]