Floyd演算法：用來找出每對點之間的最短距離。圖可以是無向圖，也可以是有向圖，邊權可為正，也可以為負，唯一要求是不能有負環。
1.初始化：將Map[][]中的資料複製到Dist[][]中作為每對頂點之間的最短路徑的初值，Pre[i][j] = i 表示 i 到 j 路徑中 j 的前一節點。
2. k 從 1 到 N 迴圈 N 次，每次迴圈中，列舉圖中不同的兩點 i，j，如果Dist[i][j] > Dist[i][k] + Dist[k][j]，則更新Dist[i][j] = Dist[i][k] + Dist[k][j]，更新Pre[i][j] = Pre[k][j]。
只要圖中不存在負環就可以得出正確的答案，關於Floyd演算法對負環的判定，參考下邊Floyd求最小環。

const int MAXN = 110;
const int INF = 0xffffff0;

int Map[MAXN][MAXN], Dist[MAXN][MAXN],Pre[MAXN][MAXN];
//Pre[i][j] = i表示i到j路徑中j的前一節點
void Floyd(int N)
{   //初始化
    for(int i = 1; i <= N; ++i)
    {
        for(int j = 1; j <= N; ++j)
        {
            Dist[i][j] = Map[i][j];
            Pre[i][j] = i;
 

        }

    }
    for(int k = 1; k <= N; ++k)
    {
        for(int i = 1; i <= N; ++i)
        {
            for(int j = 1; j <= N; ++j)
            {   //如果Dist[i][j] > Dist[i][k] + Dist[k][j]，則更新
                if(Dist[i][k] != INF && Dist[k][j] != INF && Dist[i][k] + Dist[k][j] < Dist[i][j])
 

                {
                    Dist[i][j] = Dist[i][k] + Dist[k][j];
                    Pre[i][j] = Pre[k][j];  //更新Pre[i][j]
                }    
            }
        }
    }
}

如果求點u到點v能達到的最長邊儘可能短的路徑上最長邊為多少，將迴圈內部改為如下程式碼：

int tMax;   //這裡邊求的是能達到的路徑上最長邊最小為多少  
                if(Dist[i][k] > Dist[k][j])  
                    tMax = Dist[i][k];  
                else  
                    tMax = Dist[k][j];  
                if(Dist[i][j] > tMax)  
                    Dist[i][j] = tMax;  

Floyd求最小環
不能在Map[][]陣列上直接計算，因為判斷過程中用到了Map[][]原始值。

const int MAXN = 110;
const int INF = 0xffffff0;
int temp,Map[MAXN][MAXN],Dist[MAXN][MAXN],pre[MAXN][MAXN],ans[MAXN*3];

void Solve(int i,int j,int k)
{
    temp = 0;   //回溯，儲存最小環
    while(i != j)
    {
        ans[temp++] = j;
        j = pre[i][j];
    }
    ans[temp++] = i;
    ans[temp++] = k;
}
void Floyd(int N)
{
    for(int i = 1; i <= N; ++i)
        for(int j = 1; j <= N; ++j)
        {
            Dist[i][j] = Map[i][j];
            pre[i][j] = i;
        }
    int MinCircle = INF;    //最小環
    for(int k = 1; k <= N; ++k)
    {
        for(int i = 1; i <= N; ++i)
        {
            for(int j = 1; j <= N; ++j)
            {
                if(i != j && Dist[i][j] != INF && Map[i][k] != INF && Map[k][j] != INF
                   && Dist[i][j] + Map[i][k] + Map[k][j] < MinCircle)
                {
                    MinCircle = min(MinCircle, Dist[i][j] + Map[i][k] + Map[k][j]);
                    Solve(i,j,k);   //回溯儲存最小環
                }
            }
        }

        for(int i = 1; i <= N; ++i)
        {
            for(int j = 1; j <= N; ++j)
            {
                if(Dist[i][k] != INF && Dist[k][j] != INF &&
                   Dist[i][k] + Dist[k][j] < Dist[i][j])
                {
                    Dist[i][j] = Dist[i][k] + Dist[k][j];
                    pre[i][j] = pre[k][j];  //記錄點i到點j的路徑上，j前邊的點
                }
            }
        }
    }

    if(MinCircle == INF)    //不存在環
    {
        printf("No solution.\n");
        return;
    }
    //如果求出最小環為負的，原圖必定存在負環
    for(int i = 0;i < temp; ++i)    //輸出最小環
        if(i != temp-1)
            printf("%d ",ans[i]);
        else
            printf("%d\n",ans[i]);
}