总结：Floyd弗洛伊德算法（多源最短路径）

求任意两个点之间的最短路径。这个问题这也被称为“多源最短路径”问题。

用一个二维数组存储图的信息。

e[i][j]就是i到j的路径长。
初始化：
自身到自身就是0，无法到达就是正无穷。

我们发现， 每个顶点 ，都有可能使得另外两个顶点之间的路程 变短。
。
。

假如现在只允许经过1号顶点，求任意两点之间的最短路程，应该如何求呢？
只需判断e[i][1]+e[1][j]是否比e[i][j]要小即可。
e[i][j]表示的是从i号顶点到j号顶点之间的路程。
e[i][1]+e[1][j]表示的是从i号顶点先到1号顶点，再从1号顶点到j号顶点的路程之和。
其中i是1~n循环，j也是1~n循环，
代码实现如下。

for (i = 1; i <= n; i++)
{
       for (j = 1; j <= n; j++)
       {
              if (e[i][j] > e[i][1] + e[1][j])
              e[i][j] = e[i][1] + e[1][j];
       }
 }

接下来继续求在只允许经过1和2号两个顶点的情况下任意两点之间的最短路程。
。
。
。
最后允许通过所有顶点作为中转
。
整个算法过程虽然说起来很麻烦，但是代码实现却非常简单，核心代码只有五行：

 for(k=1;k<=n;k++)  
   	for(i=1;i<=n;i++)  
 	    for(j=1;j<=n;j++)  
 			  if(e[i][j]>e[i][k]+e[k][j])  
                    e[i][j]=e[i][k]+e[k][j];

这段代码的基本思想就是：最开始只允许经过1号顶点进行中转，接下来只允许经过1和2号顶点进行中转……允许经过1~n号所有顶点进行中转，求任意两点之间的最短路程。用一句话概括就是：从i号顶点到j号顶点只经过前k号点的最短路程。

代码：

#include <bits/stdc++.h>
using namespace std;
int main()  
{  
    int e[10][10],k,i,j,n,m,t1,t2,t3;  
    int inf=99999999; //用inf(infinity的缩写)存储一个我们认为的正无穷值
    
    //读入n和m，n表示顶点个数，m表示边的条数
    scanf("%d %d",&n,&m);  
        
    //初始化
    for(i=1;i<=n;i++)  
   		 for(j=1;j<=n;j++)  
  			  if(i==j)
  			  	   e[i][j]=0;    
              else
                   e[i][j]=inf;  
                   
    //读入边
    for(i=1;i<=m;i++)  
    {        
        scanf("%d %d %d",&t1,&t2,&t3);  
        e[t1][t2]=t3;  
    }  
    
    //Floyd-Warshall算法核心语句
    for(k=1;k<=n;k++)  
   		 for(i=1;i<=n;i++)  
   			 for(j=1;j<=n;j++)  
    				if(e[i][j]>e[i][k]+e[k][j] )   
                      	  e[i][j]=e[i][k]+e[k][j];  
                      	  
    //输出最终的结果
    for(i=1;i<=n;i++)  
    {  
  		  for(j=1;j<=n;j++)  
          {  
                	printf("%10d",e[i][j]);  
          }  
          printf("\n");  
    }  
    return 0;  
}

毛学姐的模板：

#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 205;
int arr[N][N];
int n, m, st, ed;
inline void init()
{
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < n; ++j)
            arr[i][j] = (i == j ? 0 : INF);
}
 
void Floyd()
{
    for(int k = 0; k < n; ++k)
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < n; ++j) 
                arr[i][j] = min(arr[i][j], arr[i][k] + arr[k][j]);
}
 
int main()
{
    int a, b, c;
    while(cin >> n >> m) {
        init();
        for(int i = 0; i < m; ++i) {
            cin >> a >> b >> c;
            if(arr[a][b] > c) arr[a][b] = arr[b][a] = c;
        }
        Floyd();
        cin >> st >> ed;
        cout << (arr[st][ed] == INF ? -1 : arr[st][ed]) << endl;
    }
    return 0;
}