图的最短路径之Floyd算法

最新推荐文章于 2024-06-13 11:24:02 发布
最新推荐文章于 2024-06-13 11:24:02 发布
阅读量427 收藏 2
点赞数 2
分类专栏： 数据结构
原文链接：https://wangkuiwu.github.io/2013/04/15/floyd-cplus/
版权

参考：https://wangkuiwu.github.io/2013/04/15/floyd-cplus

Floyd算法介绍

弗洛伊德 Floyd 算法和 Dijkstra 算法一样，也是用于寻找给定的加权图中顶点间的最短路径算法。该算法名称以创始人——1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。

算法思想：

通过 Floyd 计算图 G=(V, E) 中各个顶点的最短路径时，需要引入一个矩阵 S，矩阵 S 中的元素 a[i][j] 表示顶点 i（第 i 个顶点）到顶点 j（第 j 个顶点）的距离。初始时，矩阵 S 中顶点 a[i][j] 的距离为顶点 i 到顶点 j 的权值，如果 i 和 j 不相邻，则 a[i][j] = ∞，如果 i == j，则 a[i][j] = 0。

任意节点 i 到节点 j 的最短路径有两种可能：

  1. 直接从 i 到 j。
  2. 从 i 经过若干个节点 k 到 j。

如果我们用 a[i][j] 表示节点 i 到节点 j 的最短路径的距离，对于每一个节点 k，将节点 k 作为中介点，都需要取检查 a[i][k] + a[k][j] < a[i][j]。如果该条件成立，需要设置 a[i][j] = a[i][k] + a[k][j]，遍历每个节点 k，每次更新的是除了第 k 行和第 k 列的数。

单纯的理论可能比较难以理解，下面通过实例来对该算法进行说明。

Floyd算法图解

Floyd算法-图1

图 G4

以上图 G4 为例，来对 Floyd 算法进行演示。

首先初始化矩阵如下：

Floyd算法-图2

下面继续步骤演示：

Floyd算法-图3

步骤说明：

第1步：以顶点 A（第零个顶点，对应下标为 0）为中介点，若 a[i][j] > a[i][0] + a[0][j]，则设置 a[i][j] = a[i][0] + a[0][j]。以顶点 a[1][6] 为例，矩阵初始化时，a [1][6] = ∞，现在以 A 作为中介点时，因为 a[1][0] = 12，a[0][6] = 14，而 ∞ > a[1][0] + a[0][6] = 26，所以应该更新点 B 和点 G 之间的距离 a[1][6] = 26。

第2步：以顶点 B（第一个顶点，对应下标为 1）为中介点，若 a[i][j] > a[i][1] + a[1][j]，则设置 a[i][j] = a[i][1] + a[1][j]。以顶点 a[2][6] 为例，上一步后，a [2][6] = ∞，现在以 B 作为中介点时，因为 a[2][1] = 10，a[1][6] = 26，而 ∞ > a[1][0] + a[0][6] = 36，所以应该更新点 C 和点 G 之间的距离 a[2][6] = 36。

第3步：以顶点 C（第二个顶点，对应下标为 2）为中介点，……

……

同理，依次将顶点 D, E, F, G 作为中介点，并更新 a[i][j] 的大小即可，最后就能得到任意两点之间的最短路径。

算法分析：

Floyd 算法是一种动态规划算法，边权可正可负，此算法简单有效。

优点：理解容易，可以算出任意两个节点之间的最短距离，代码编写简单。

缺点：时间复杂度比较高，不适合计算大量数据。

算法时间复杂度为 O(n^3)，空间复杂度为 O(n^2)。

Floyd算法实现

图的邻接矩阵实现Floyd算法

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

#define MAX 100
#define INF (~(0x1 << 31)) //无穷大(0x7FFFFFFF)

const int VEXNUM = 7;

struct EData
{
    char start; //边的起点
    char end;   //边的终点
    int weight; //边的权重

    EData() {}
    EData(char s, char e, int w) : start(s), end(e), weight(w) {}
};

class MatrixUDG
{
private:
    char mVexs[MAX];       //顶点集合，如：{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    int mVexNum;           //顶点数，如：7
    int mEdgNum;           //边数
    int mMatrix[MAX][MAX]; //邻接矩阵
public:
    //创建图(手动输入)
    MatrixUDG();
    //创建图(用提供的矩阵)
    MatrixUDG(char *vexs, int vNum, int matrix[][VEXNUM]);
    ~MatrixUDG();
    //打印邻接表
    void print();
    //Floyd最短路径算法
    void Floyd(int path[][VEXNUM], int dist[][VEXNUM]);

private:
    //输入一个合法字母
    char readChar();
    //获得一个字母在顶点数组的下标
    int getPosition(char ch);
    //返回顶点v的第一个邻接顶点的索引，失败返回-1
    int firstVertex(int v);
    //范围顶点v相对于w的下一个邻接顶点的索引，失败返回-1
    //比如: A和C, D, E有连接，则A相对于C的下一个结点为D，即返回D的索引
    int nextVertex(int v, int w);
    //获取图中的边
    EData *getEdge();
    //对边按照权值从小到大进行排序
    void sortEdges(EData *edges, int eNum);
    //获取i的终点
    int getEnd(int *vEnds, int i);
};

MatrixUDG::MatrixUDG()
{
    char c1, c2;
    int p1, p2;
    int i, j;
    int weight;

    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数：";
    cin >> mEdgNum;
    if (mVexNum < 1 || mEdgNum < 1 || (mEdgNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误！" << endl;
        return;
    }
    //初始化顶点
    for (i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i] = readChar();
    }
    //初始化边的权值
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            if (i == j)
                mMatrix[i][j] = 0;
            else
                mMatrix[i][j] = INF;
        }
    }
    //初始化边的权值，根据用户输入进行初始化
    for (i = 0; i < mEdgNum; ++i)
    {
        cout << "edge(" << i << "):";
        c1 = readChar();
        c2 = readChar();
        cin >> weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边错误！" << endl;
            return;
        }
        mMatrix[p1][p2] = weight;
        mMatrix[p2][p1] = weight;
    }
}

MatrixUDG::MatrixUDG(char *vexs, int vNum, int matrix[][VEXNUM])
{
    if (!vexs || !*matrix)
        return;
    int i, j;
    mVexNum = vNum;
    //初始化顶点
    for (i = 0; i < mVexNum; ++i)
        mVexs[i] = vexs[i];

    //初始化边
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            mMatrix[i][j] = matrix[i][j];
        }
    }

    //统计边的数目
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            if (i != j && mMatrix[i][j] != INF)
            {
                ++mEdgNum;
            }
        }
    }
    mEdgNum /= 2;
}

MatrixUDG::~MatrixUDG()
{
}

int MatrixUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i] == ch)
            return i;
    }
    return -1;
}

char MatrixUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

/*
返回顶点v的第一个邻接顶点的索引，失败返回-1
*/
int MatrixUDG::firstVertex(int v)
{
    if (v < 0 || v > (mVexNum - 1))
        return -1;
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mMatrix[v][i] != 0 && mMatrix[v][i] != INF)
            return i;
    }
    return -1;
}
/*
返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1
比如:A和C,D,E有连接，则A相对于C的下一个结点为D，即返回D的索引
*/
int MatrixUDG::nextVertex(int v, int w)
{
    if (v < 0 || v > (mVexNum - 1) || w < 0 || w > (mVexNum - 1))
        return -1;
    for (int i = w + 1; i < mVexNum; ++i)
    {
        if (mMatrix[v][i] != 0 && mMatrix[v][i] != INF)
            return i;
    }
    return -1;
}

//获取图中的边
EData *MatrixUDG::getEdge()
{
    int i, j;
    int index = 0;
    EData *edges = new EData[mEdgNum];
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = i + 1; j < mVexNum; ++j)
        {
            if (mMatrix[i][j] != INF)
            {
                edges[index].start = mVexs[i];
                edges[index].end = mVexs[j];
                edges[index].weight = mMatrix[i][j];
                ++index;
            }
        }
    }
    return edges;
}

//对边按照权值大小进行排序(由小到大)
void MatrixUDG::sortEdges(EData *edges, int eNum)
{
    //直接调用STL排序
    std::sort(edges, edges + eNum, [](EData &edge1, EData &edge2) -> bool
              { return edge1.weight < edge2.weight; });
}

int MatrixUDG::getEnd(int *vEnds, int i)
{
    //相当于并查集的操作
    while (vEnds[i] != 0)
    {
        i = vEnds[i];
    }
    return i;
}

/*
 * Floyd最短路径算法，即统计图中各个顶点的最短路径
 * 参数说明：
 * path: 路径
 * dist: 长度数组。即dist[i][j]=sum表示，第i个顶点到第j个顶点的最短路径长度是sum
 */
void MatrixUDG::Floyd(int path[][VEXNUM], int dist[][VEXNUM])
{
    int i, j, k;
    int tmp;
    //初始化
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            dist[i][j] = mMatrix[i][j]; //第i个顶点到第j个顶点的路径长度为i到j的权值
            path[i][j] = j;             //第i个顶点到第j个顶点的最短路径是经过第j个顶点
        }
    }
    //计算最短路径
    for (k = 0; k < mVexNum; ++k)
    {
        for (i = 0; i < mVexNum; ++i)
        {
            for (j = 0; j < mVexNum; ++j)
            {
                //如果经过下标为k顶点路径比原两点间路径更短，则更新dist[i][j]和path[i][j]
                tmp = (dist[i][k] == INF || dist[k][j] == INF) ? INF : dist[i][k] + dist[k][j];
                if (dist[i][j] > tmp)
                {
                    dist[i][j] = tmp;        //i到j最短路径对应的值设为更小的一个(即经过 k)
                    path[i][j] = path[i][k]; //i到j最短路径对应的路径，经过 k
                }
            }
        }
    }
    //打印Floyd最短路径的结果
    cout << "Floyd:" << endl;
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            cout << dist[i][j] << "\t";
        }
        cout << endl;
    }
}

void MatrixUDG::print()
{
    for (int i = 0; i < mVexNum; ++i)
    {
        for (int j = 0; j < mVexNum; ++j)
        {
            if (mMatrix[i][j] == INF)
            {
                cout << "INF"
                     << "\t";
            }
            else
            {
                cout << mMatrix[i][j] << "\t";
            }
        }
        cout << endl;
    }
}

int main()
{
    char vexs[VEXNUM] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int matrix[VEXNUM][VEXNUM] = {
        {0, 12, INF, INF, INF, 16, 14},
        {12, 0, 10, INF, INF, 7, INF},
        {INF, 10, 0, 3, 5, 6, INF},
        {INF, INF, 3, 0, 4, INF, INF},
        {INF, INF, 5, 4, 0, 2, 8},
        {16, 7, 6, INF, 2, 0, 9},
        {14, INF, INF, INF, 8, 9, 0}};

    // 1. 根据提供的数据生成
    MatrixUDG mudg(vexs, vNum, matrix);
    mudg.print(); //打印图
    int path[VEXNUM][VEXNUM];
    int dist[VEXNUM][VEXNUM];
    //Floyd算法获取各个顶点之间的最短距离
    mudg.Floyd(path, dist);
    //2. 手动生成
    // MatrixUDG mudg1;
    // mudg1.print();
}

运行结果：

$ ./test
0       12      INF     INF     INF     16      14
12      0       10      INF     INF     7       INF
INF     10      0       3       5       6       INF
INF     INF     3       0       4       INF     INF
INF     INF     5       4       0       2       8
16      7       6       INF     2       0       9
14      INF     INF     INF     8       9       0
Floyd:
0       12      22      22      18      16      14
12      0       10      13      9       7       16
22      10      0       3       5       6       13
22      13      3       0       4       6       12
18      9       5       4       0       2       8
16      7       6       6       2       0       9
14      16      13      12      8       9       0

图的邻接表实现Flody算法

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

#define MAX 100
#define INF (~(0x1 << 31)) //无穷大(0x7FFFFFFF)

const int VEXNUM = 7;

#define MAX 100
#define INF (~(0x1 << 31)) //最大值

struct EData
{
    char start; //边的起点
    char end;   //边的终点
    int weight; //边的权重

    EData() {}
    EData(char s, char e, int w) : start(s), end(e), weight(w) {}
};

class ListUDG
{
private:
    //每一条边
    struct ENode
    {
        int iVex = 0;           //指向的顶点的位置
        int weight = 0;         //该边的权
        ENode *nextEdge = NULL; //指向顶点的下一条边的指针
    };
    //数组中存储的顶点
    struct VNode
    {
        char data;
        ENode *firstEdge = NULL; //指向第一条该顶点的边
    };

private:
    int mVexNum;      //图的顶点数目
    int mEdgeNum;     //图的边的数目
    VNode mVexs[MAX]; //存储顶点
public:
    //创建邻接表对应的图(自己收入)
    ListUDG();
    //创建邻接表对应的图(用已提供的数据)
    ListUDG(char *vexs, int vNum, EData *edges[], int eNum);
    ~ListUDG();
    //打印邻接表
    void print();
    //Floyd最短路径算法
    void Floyd(int path[][VEXNUM], int dist[][VEXNUM]);

private:
    //读取一个合法的输入字符
    char readChar();
    //返回字符ch在的位置
    int getPosition(char ch);
    //将node结点链接到list的最后
    void linkLast(ENode *list, ENode *node);
    //获取边<start, end>的权值，若start和end不是连通的，则返回无穷大
    int getWeight(int start, int end);
    //获取图中的边
    EData *getEdges();
    //对边按照权值从小到大进行排序
    void sortEdges(EData *edges, int eNum);
    //获取i的终点
    int getEnd(int *vEnds, int i);
};

ListUDG::ListUDG()
{
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    int weight;

    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgeNum;
    if (mVexNum > MAX || mEdgeNum > MAX || mVexNum < 1 || mEdgeNum < 1 || (mEdgeNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误！" << endl;
        return;
    }
    //初始化邻接表的顶点
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i].data = readChar();
        mVexs[i].firstEdge = NULL;
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        cout << "edge(" << j << "):";
        c1 = readChar();
        c2 = readChar();
        cin >> weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);

        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误！" << endl;
            return;
        }
        //初始化node1
        node1 = new ENode();
        node1->iVex = p2;
        node1->weight = weight;
        //将node1链接到p1所在链表的末尾
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        //初始化node2
        node2 = new ENode();
        node2->iVex = p1;
        node2->weight = weight;
        //将node2链接到p2所在链表的末尾
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::ListUDG(char *vexs, int vNum, EData *edges[], int eNum)
{
    if (vNum > MAX || eNum > MAX)
        return;
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    int weight;
    //初始化顶点数和边数
    mVexNum = vNum;
    mEdgeNum = eNum;
    //初始化邻接表的顶点
    for (int i = 0; i < mVexNum; ++i)
    {
        mVexs[i].data = vexs[i];
        mVexs[i].firstEdge = NULL;
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        //读取边的起始顶点和结束顶点
        c1 = edges[j]->start;
        c2 = edges[j]->end;
        weight = edges[j]->weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误！" << endl;
            return;
        }
        //初始化node1
        node1 = new ENode();
        node1->iVex = p2;
        node1->weight = weight;
        //将node1链接到p1所在的链表末尾
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        //初始化node2
        node2 = new ENode();
        node2->iVex = p1;
        node2->weight = weight;
        //将node2链接到p2所在链表末尾
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::~ListUDG()
{
}

void ListUDG::linkLast(ENode *list, ENode *node)
{
    ENode *p = list;
    while (p->nextEdge)
        p = p->nextEdge;
    p->nextEdge = node;
}

int ListUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i].data == ch)
            return i;
    }
    return -1;
}

char ListUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

int ListUDG::getWeight(int start, int end)
{
    if (start == end)
        return 0;
    ENode *node = mVexs[start].firstEdge;
    while (node != NULL)
    {
        if (end == node->iVex)
        {
            return node->weight;
        }
        node = node->nextEdge;
    }
    return INF;
}

//获得图中的边
EData *ListUDG::getEdges()
{
    int i;
    int index = 0;
    ENode *node = NULL;
    EData *edges = new EData[mEdgeNum];
    for (i = 0; i < mVexNum; ++i)
    {
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            if (node->iVex > i)
            {
                edges[index].start = mVexs[i].data;
                edges[index].end = mVexs[node->iVex].data;
                edges[index].weight = node->weight;
                ++index;
            }
            node = node->nextEdge;
        }
    }
    return edges;
}

//对边按照权值大小进行排序(由小到大)
void ListUDG::sortEdges(EData *edges, int eNum)
{
    if (!edges)
        return;
    //直接调用STL排序
    std::sort(edges, edges + eNum, [](EData &edge1, EData &edge2) -> bool
              { return edge1.weight < edge2.weight; });
}

int ListUDG::getEnd(int *vEnds, int i)
{
    //相当于并查集的操作
    while (vEnds[i] != 0)
    {
        i = vEnds[i];
    }
    return i;
}

/*
 * Floyd最短路径算法，即统计图中各个顶点的最短路径
 * 参数说明：
 * path: 路径
 * dist: 长度数组。即dist[i][j]=sum表示，第i个顶点到第j个顶点的最短路径长度是sum
 */
void ListUDG::Floyd(int path[][VEXNUM], int dist[][VEXNUM])
{
    int i, j, k;
    int tmp;
    //初始化
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            dist[i][j] = getWeight(i, j); //第i个顶点到第j个顶点的路径长度为i到j的权值
            path[i][j] = j;               //第i个顶点到第j个顶点的最短路径是经过第j个顶点
        }
    }
    //计算最短路径
    for (k = 0; k < mVexNum; ++k)
    {
        for (i = 0; i < mVexNum; ++i)
        {
            for (j = 0; j < mVexNum; ++j)
            {
                //如果经过下标为k顶点路径比原两点间路径更短，则更新dist[i][j]和path[i][j]
                tmp = (dist[i][k] == INF || dist[k][j] == INF) ? INF : dist[i][k] + dist[k][j];
                if (dist[i][j] > tmp)
                {
                    dist[i][j] = tmp;        //i到j最短路径对应的值设为更小的一个(即经过 k)
                    path[i][j] = path[i][k]; //i到j最短路径对应的路径，经过 k
                }
            }
        }
    }
    //打印Floyd最短路径的结果
    cout << "Floyd:" << endl;
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            cout << dist[i][j] << "\t";
        }
        cout << endl;
    }
}

void ListUDG::print()
{
    ENode *node;
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << i << "(" << mVexs[i].data << "):";
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            cout << node->iVex << "(" << mVexs[node->iVex].data << ")";
            node = node->nextEdge;
        }
        cout << endl;
    }
}

int main(int argc, char **argv)
{
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    EData *edges[] = {
        new EData('A', 'B', 12),
        new EData('A', 'F', 16),
        new EData('A', 'G', 14),
        new EData('B', 'C', 10),
        new EData('B', 'F', 7),
        new EData('C', 'D', 3),
        new EData('C', 'E', 5),
        new EData('C', 'F', 6),
        new EData('D', 'E', 4),
        new EData('E', 'F', 2),
        new EData('E', 'G', 8),
        new EData('F', 'G', 9),
    };
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int eNum = sizeof(edges) / sizeof(edges[0]);
    //1. 根据提供的数据生成
    ListUDG ludg(vexs, vNum, edges, eNum);
    ludg.print();
    int path[VEXNUM][VEXNUM];
    int dist[VEXNUM][VEXNUM];
    //Floyd算法获取各个顶点之间的最短距离
    ludg.Floyd(path, dist);
    //2. 手动输入
    // ListUDG ludg;
    // ludg.print();
    return 0;
}

运行结果：

$ ./test
0(A):1(B)5(F)6(G)
1(B):0(A)2(C)5(F)
2(C):1(B)3(D)4(E)5(F)
3(D):2(C)4(E)
4(E):2(C)3(D)5(F)6(G)
5(F):0(A)1(B)2(C)4(E)6(G)
6(G):0(A)4(E)5(F)
Floyd:
0       12      22      22      18      16      14
12      0       10      13      9       7       16
22      10      0       3       5       6       13
22      13      3       0       4       6       12
18      9       5       4       0       2       8
16      7       6       6       2       0       9
14      16      13      12      8       9       0
code_peak
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++实现多源最短路径之Floyd算法示例
08-29
C++实现多源最短路径之Floyd算法示例 C++实现多源最短路径之Floyd算法是一种常用的图形算法，它可以解决多源最短路径问题。该算法的主要思想是通过动态规划来计算图形中所有顶点之间的最短路径。下面是关于C++实现...
floyd 算法模板详解(适合新手)
qq_61935738的博客
08-29 911
floyd 算法模板详解(适合新手)
弗洛伊德（Floyd)算法详解
热门推荐
weixin_60737527的博客
03-27 8万+
弗洛伊德（Floyd)算法详解
多源最短路径算法 -- 弗洛伊德（Floyd）算法
最新发布
qq_67342067的博客
06-13 1325
总的来说，Floyd算法是一种计算图中所有顶点对之间最短路径的动态规划算法，它能够处理包含负权边的图，但不允许存在负权回路。适用于小型到中等规模稠密图的算法，尤其是在需要全局最短路径信息时。对于大型稀疏图或者单源最短路径问题，其他算法如Dijkstra算法可能更加合适。
常用算法——弗洛伊德(Floyd)算法(最短路径问题)
笔记别偷看
11-18 2万+
弗洛伊德(Floyd)算法介绍 和Dijkstra 算法一样，弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。该算法名称以创始人之一、1978 年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名 弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径 迪杰斯特拉算法用于计算图中某一个顶点到其他顶点的最短路径。 弗洛伊德算法VS 迪杰斯特拉算法：迪杰斯特拉算法通过选定的被访问顶点，求出从出发访问顶点到其他顶点的最短路径；弗洛伊德算法中每一个顶点都是出发访问点，所以
Floyd算法详解（附matlab代码）
yyyyyyep的博客
06-27 4817
Floyd算法又称为插点法，是一种利用的思想寻找给定的中多源点之间的算法，与类似。该算法名称以创始人之一、1978年获得者、计算机科学系教授命名。Floyd算法可以给出网络中任意两个节点之间的最短路径，因此它是比Dijkstra更一般的算法。Floyd算法的思想是将n个节点的网络表示为n行n列的矩阵，而矩阵中的元素(i,j)表示从节点i到节点j的距离dij，如果两点直接没有边相连，则相应的元素就是无穷(∞).
Floyd （弗洛伊德）算法简述
慕羽★的博客
10-15 2万+
Floyd在1962年由Robert Floyd以其当前公认的形式出版。算法作为三个嵌套for循环的现代公式首先由Peter Ingerman在1962年描述。Floyd 算法是解决图论问题的比较经典的算法，是解决给定的加权图中顶点间的最短路径的一种算法，可以正确处理有向图的最短路径问题。
C语言实现图的最短路径Floyd算法
12-31
Floyd算法直接使用二维数组求出所有顶点到所有顶点的最短路径。 D代表顶点到顶点的最短路径权值和的矩阵。 P代表对应顶点的最小路径的前驱矩阵。 以下程序在DEV C++中调试运行通过。 #include <stdio> #define ...
C例子：最短路径（floyd算法）
10-11
该程序是我写的博客“一起talk C栗子吧（第五十五回：C语言实例--图的最短路径三）”的配套程序，共享给大家使用
最短路径的Dijsktra算法及Floyd算法
11-22
本文将详细探讨两种著名的解决最短路径问题的算法：Dijkstra算法和Floyd算法。 **Dijkstra算法** Dijkstra算法是由荷兰计算机科学家艾兹格&middot;迪科斯彻在1956年提出的，它主要用于寻找带权重的无环图中从单一源点到...
最短路径_Floyd算法_matlab实现.doc
05-07
Floyd 算法是一种常用的图论算法，用于计算图中的最短路径。该算法可以处理含有负权边的图，且可以检测图中的负回路。本文将详细介绍 Floyd 算法的原理、实现步骤以及 MATLAB 实现代码。 Floyd 算法原理 Floyd ...
floyd最短路径算法MATLAB代码
08-29
求最短路径的Floyd算法实现，无向图和有向图均适用。1先区别有向图和无向图，2输入顶点数和边数并检查合法性，3输入每边的起点、终点、权重并检查合法性，并初始化邻接矩阵和路径矩阵，4调用自定义函数Floyd
最短路径算法 floyd
06-08
Floyd算法的核心思想是通过逐步考虑所有可能的中间节点来寻找最短路径。初始时，算法假设每个节点到自身的距离为0，直接相邻节点之间的距离为边的权重。然后，对于每一对节点i和j，算法会尝试通过所有的中间节点k来...
每对顶点之间最短路径Floyd算法
12-14
Floyd-Warshall算法，又叫Floyd算法，用于求每对顶点之间最短路径
【老生谈算法】最短路径的Floyd算法的Matlab程序.doc
07-02
Floyd算法在最短路径问题中的应用 Floyd算法是一种用来解决图论中最短路径问题的算法，โดย Floyd R W 提出。该算法的主要思想是递推生成一个矩阵序列，其中每个元素表示从顶点到顶点的路径上所经过的顶点序号不...
算法-最短路径-Floyd算法
05-21
虽然这在大规模图上可能会变得较慢，但对于中等大小的图，Floyd算法的效率是可接受的，因为它可以一次性找到所有顶点对的最短路径，而不需要多次遍历图。 在给出的文件中，"Floyd.cpp"可能是实现Floyd算法的C++代码...
Floyd - Warshall（弗洛伊德算法）
yuewenyao的博客
07-12 6万+
简介：Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 eg：暑假，小哼准备去一些城市旅游。有些城市之间有公路，有些城市之间则没有，如下图。为了节省经费及方便计划旅程，小哼希望在出发前知道任意两个城市之...
Floyd算法详解——包括解题步骤与编程
SweeNeil
03-21 6万+
一、Floyd算法原理 Floyd算法是一个经典的动态规划算法，它又被称为插点法。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。Floyd算法是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法,算法目标是寻找从点i到点j的最短路径。 从任意节点i到任意节点j的最短路径不外乎2种可能，1是直接从i到j，2是从i经过若干个节点k到j...
图论：Floyd算法
普罗米修斯的博客
08-26 2366
【 1. Floyd算法简介 】 背景 Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 用途 Floyd算法适用于APSP(All Pairs Shortest Paths，多源最短路径)，是一种动态规划算法，稠密图效果最佳，边权可正可负，但不许有包含带负权值的边组成的回路。 复杂度 时间复杂度：O(n3)O(n^3)O(n3)，时间
图算法实现：Floyd 最短路径算法详解
"这篇文档是关于最短路径算法的分析，特别提到了Floyd算法的实现。" 在图论和计算机科学中，最短路径算法是寻找图中两个节点之间路径长度最小的算法。这些算法广泛应用于网络路由、交通规划、社交网络分析等多个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值