最短路径算法——弗洛伊德算法(Floyd)

算法的本质

  • 用三重循环来清算每个点 对 缩小相邻任意“点对儿”距离的贡献
  • 即每个顶点都有可能使得另外两个顶点之间的距离变短
  • 贡献核心在于两边之和大于第三边
  • 清算完成后即得任意两点的最短路径

算法的基本思想

  • 最开始只允许经过1号顶点进行中转
  • 接下来只允许经过1和2号顶点进行中转
  • ……
  • 允许经过1~n号所有顶点进行中转
  • 求任意两点之间的最短路程
  • 用一句话概括就是:从i号顶点到j号顶点只经过前k号点的最短路程
  • 其实这是一种“动态规划”的思想

C语言伪代码表示的算法

void ShortestPath_FLOYD(MGraph G, PathMatrix &P[], DistancMatrix &D){
    // 用Floyd算法求有向网G中各对顶点v和w之间的最短路径P[v][w]及其
    // 带权长度D[v][w]。若P[v][w][u]为TRUE,则u是从v到w当前求得最短路径上的顶点
    for(v = 0; v < G.vexnum; ++ v)// 各对结点之间初始已知路径及距离
        for(w = 0; w < G.vexnum; ++ w){
            D[v][w] = G.arcs[v][w];
            for(u = 0; u < G.vexnum; ++ u) P[v][w][u] = FALSE;
            if(D[v][w] < INFINITY){// 从v到w有直接路径
                P[v][w][v] = TRUE; P[v][w][w] = TRUE;
            }// if
        }// for
    for(u = 0; u < G.vexnum; ++ u)
        for(v = 0; v < G.vexnum; ++ v)
            for(w = 0; w < G.vexnum; ++ w)
                if(D[v][u] + D[u][w] < D[v][w]){// 从v经u到w的一条路径更短
                    D[v][w] = D[v][u] + D[u][w];
                    for(i = 0; i < G.vexnum; ++ i)
                        P[v][w][i] = P[v][u][i] || P[u][w][i];
                }// if
}// ShortestPath_FLOYD

核心代码就五行

// 核心代码
for(u = 0; u < G.vexnum; ++ u)
    for(v = 0; v < G.vexnum; ++ v)
        for(w = 0; w < G.vexnum; ++ w)
            if(D[v][u] + D[u][w] < D[v][w])// 从v经u到w的一条路径更短
                D[v][w] = D[v][u] + D[u][w];

C语言程序

#include <stdio.h>
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;
} 
时间: 2024-10-29 15:08:54

最短路径算法——弗洛伊德算法(Floyd)的相关文章

最短路径之弗洛伊德算法(Floyd)

Floyd算法又称为插点法,是一种用于寻找给定的加权图中多源点之间最短路径的算法. 路径矩阵 通过一个图的权值矩阵求出它的每两点间的最短路径矩阵. 从图的带权邻接矩阵A=[a(i,j)] n×n开始,递归的进行n次更新,即由矩阵D(0)=A,按一个公式,构造出矩阵D(1): 又用同样地公式由D(1)构造出D(2):--:最后又用同样的公式由D(n-1)构造出矩阵D(n).矩阵D(n) 的 i 行 j 列元素便是 i 号顶点到 j 号顶点的最短路径长度,称D(n)为图的距离矩阵,同时还可引入一个后

两点之间最短路径:弗洛伊德算法

弗洛伊德算法是计算无向有权图中两点间最短路径的算法,复杂度为O(n^3).其思路是将两点间距离分为过(指定的)第三点或是不过,然后取它们的最小值,如此循环就可以得到两点之间真正的最小值. void floyd() { for (int k = 0; k < n; ++k) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { //在当前i到j经过k点的路径与直连的路径中选最短 matrix[i][j] = min(ma

Floyd算法(弗洛伊德算法)

算法描述: Floyd算法又称为弗洛伊德算法,插点法,是一种用于寻找给定的加权图中顶点间最短路径的算法.从图的带权邻接矩阵A=[a(i,j)] n×n开始,递归地进行n次更新,即由矩阵D(0)=A,按一个公式,构造出矩阵D(1):又用同样地公式由D(1)构造出D(2):……:最后又用同样的公式由D(n-1)构造出矩阵D(n).矩阵D(n)的i行j列元素便是i号顶点到j号顶点的最短路径长度,称D(n)为图的距离矩阵,同时还可引入一个后继节点矩阵path来记录两点间的最短路径. 核心思路:通过一个图

数据结构(五)图---最短路径(弗洛伊德算法)

一:定义 弗洛伊德算法是用来求所有顶点到所有顶点的时间复杂度. 虽然我们可以直接对每个顶点通过迪杰斯特拉算法求得所有的顶点到所有顶点的时间复杂度,时间复杂度为O(n*3),但是弗洛伊德算法更加简洁优雅 二:弗洛伊德的使用介绍 若是求一个顶点到其他顶点的最短距离,例如迪杰斯特拉算法,我们的距离数组和路径数组使用一维即可,但是我们这里是获取所有顶点到其余顶点的最短距离,所以我们对于数组和路径都需要使用二维数组来表示 下面我们使用一个有三个顶点的图来进行讲解: (1)我们先定义两个二维数组D0[3][

算法:最短路径之弗洛伊德(Floyd)算法

https://cloud.tencent.com/developer/article/1012420 为了能讲明白弗洛伊德(Floyd)算法的主要思想,我们先来看最简单的案例.图7-7-12的左图是一个简单的3个顶点的连通网图. 我们先定义两个二维数组D[3][3]和P[3][3], D代表顶点与顶点的最短路径权值和的矩阵.P代表对应顶点的最短路径的前驱矩阵.在未分析任何顶点之前,我们将D命名为D(-1),其实它就是初始图的邻接矩阵.将P命名为P(-1), 初始化为图中的矩阵. 首先我们来分析

最短路径(弗洛伊德算法)

假设条件同上.. 整个算法最核心的,个人觉得就是一个公式: weight[a][b] = min{weight[a][b], weight[a][c]+weight[c][b]} 即,从一点到另外一点的最短距离,是在直线和经过一个中间点的'绕路'距离之间求最短..然后利用上一次的结果迭代.. /* * author: buer * github: buer0.github.com */ #include <stdio.h> #include <stdlib.h> #define M

顶点最短路径(弗洛伊德算法)

将每个顶点之间的距离做成一个矩阵 int[][] matrix = { {0,5,2,inf,inf,inf,inf}, {5,2,inf,1,6,inf,inf}, {2,inf,0,6,inf,8,inf}, {inf,1,6,0,1,2,inf}, {inf,6,inf,1,0,inf,7}, {inf,inf,8,2,inf,0,3}, {inf,inf,inf,inf,7,3,0}, }; 更新最短距离 Math.min()将两者进行比较选择最小的存入矩阵 Math.min(matri

图的算法---弗洛伊德算法

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; //读入边 f

Floyd(弗洛伊德算法)---每对顶点的最短路径---《数据结构》严蔚敏

// exam1.cpp : 定义控制台应用程序的入口点. // #include "stdafx.h" #include <iostream> #include <stack> using namespace std; #define MAXVEX 20 #define INT_MAX 10000 typedef struct ArcNode { int adj; void* info; }ArcNode; typedef ArcNode AdjMat[MAX