图的最短路径之Floyd算法

Floyd算法求图最短路径及实现 最短路径搜索是基于Floyd算法的改进。Floyd算法的基本思想 图1 选i到j的最短路径 Floyd算法的基本思想是:比较直接从i到j和从i经k到j的路径长度,选择较短的一条。当此条最短路径选定后,无论是i->j,或者是i->k->j都可以抽象成i->j,既都是以i为起点,j为终点的一条最短路径。 此时,考虑i,j,k,之外的另一节点n,要找i到n的最短路径。 图2 重复上述比较, 阅读详情

参考: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
弗洛伊德(Floyd)算法详解 阅读详情

相关推荐

详解图的最短路径算法(BFS、Dijkstra、Floyd)(附上图解步骤)

详解图的最短路算法、针对BFS、Dijkstra、Floyd算法写出详细的图解、解题步骤

叶小树咯 8105

floyd 算法模板详解(适合新手)

floyd 算法模板详解(适合新手)

qq_61935738的博客 1120

图的最短路径算法及matlab实现(Dijkstra算法、Floyd算法、Bellman-Ford算法、Johnson 算法)

图的最短路径算法 Dijkstra算法 Dijkstra算法研究的是从初始点到其他任一结点的最短路径,即单源最短路径问题,其对图的要求是不存在负权值的边。 Dijkstra算法主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。 举例说明: 已知图的邻接矩阵为 [050∞4025105001520∞25∞1501020∞4020100102525∞20100551025∞25550] \le...

wmhsjtu的博客 6879

常用算法——弗洛伊德(Floyd)算法(最短路径问题)

弗洛伊德(Floyd)算法介绍 和Dijkstra 算法一样,弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。该算法名称以创始人之一、1978 年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名 弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径 迪杰斯特拉算法用于计算图中某一个顶点到其他顶点的最短路径。 弗洛伊德算法VS 迪杰斯特拉算法:迪杰斯特拉算法通过选定的被访问顶点,求出从出发访问顶点到其他顶点的最短路径;弗洛伊德算法中每一个顶点都是出发访问点,所以

笔记别偷看 2万+

图的最短路径:Floyd、DisjKstra、Bellman-Ford、SPFA算法

问题描述: 给定一个有向图的邻接矩阵graph,graph[i][j]表示点i到点j的路径长,我们需要对图进行稀疏,将graph[i][j]转换为点i到点j的最短路径长。 图的稀疏是图中比较经典的问题,常见的算法有Floyd、DisjKstra、SPFA算法,下面将进行详述。 一、Floyd算法\color{blue}{Floyd算法}Floyd算法 Floyd-Warshall算法(Floyd-...

hestyle的博客 1966

图-最短路径—Dijkstra算法和Floyd算法

一、Dijkstra算法 1.定义概览:单源最短路径算法 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法,算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题,算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算...

凌凌小博客 2008

Floyd算法详解(附matlab代码)

Floyd算法又称为插点法,是一种利用的思想寻找给定的中多源点之间的算法,与类似。该算法名称以创始人之一、1978年获得者、计算机科学系教授命名。Floyd算法可以给出网络中任意两个节点之间的最短路径,因此它是比Dijkstra更一般的算法。Floyd算法的思想是将n个节点的网络表示为n行n列的矩阵,而矩阵中的元素(i,j)表示从节点i到节点j的距离dij,如果两点直接没有边相连,则相应的元素就是无穷(∞).

yyyyyyep的博客 6303

Floyd (弗洛伊德)算法简述

Floyd在1962年由Robert Floyd以其当前公认的形式出版。算法作为三个嵌套for循环的现代公式首先由Peter Ingerman在1962年描述。Floyd 算法是解决图论问题的比较经典的算法,是解决给定的加权图中顶点间的最短路径的一种算法,可以正确处理有向图的最短路径问题。

慕羽★的博客 2万+

图的最短路径算法——Floyd算法

图的最短路径算法 声明:图源 https://blog.youkuaiyun.com/qq_35644234/article/details/60875818 算法代码源 https://www.jianshu.com/p/f910ce1fe7b1 本文主要是代码理解的注解以及调试。。。哇,我觉得代码写的清晰的人真的很厉害啊 Floyd算法 转自:作者:廖少少 链接:https://www.jianshu....

nicezheng_1995 1143

掌握Floyd算法:图的最短路径实战解析

Floyd算法是一种用于寻找给定加权图中所有顶点对之间最短路径的算法。它由Robert W. Floyd在1962年提出,并以其实现的简洁性和强大的适用性而闻名。算法能够处理包含正权重和负权重边的图,但不适用于包含负权重环的情况。Floyd算法的吸引力在于其简单易懂,且对稠密图的效率较高,这使其成为计算机网络、交通规划、以及各种路径优化问题中的首选算法之一。接下来,我们将深入探讨图的定义、权重概念,以及Floyd算法的具体实现和优化。图是计算机科学中广泛用于模拟各种关系的数据结构。

weixin_28850145的博客 1312

【AAAI2025】【小目标检测】FBRT-YOLO:更快速、更优的实时航拍图像检测方法

FBRT-YOLO是一种新型实时航拍图像检测方法,针对小目标检测的精度与效率平衡问题提出创新解决方案。该方法通过两个轻量级模块显著提升性能:特征互补映射模块(FCM)将浅层空间位置信息深度整合至网络深层,缓解信息失衡;多核感知单元(MKP)采用多尺度卷积增强多目标感知能力。实验表明,在VisDrone、UAVDT和AI-TOD数据集上,FBRT-YOLO在检测精度和速度方面均优于现有实时检测器,特别适用于资源受限的飞行设备。该模型通过精简网络结构,在保持高性能的同时降低了计算负担,为航拍实时检测提供了高效解

weixin_44184852的博客 2910

图的最短路径的Dijkstra算法及Floyd算法

文章目录

薛定谔的猫的博客 1490

全差分运放+开关电容共模反馈

设计一种CMOS全差分折叠式共源共栅结构的运放,其共模反馈用的是开关电容(SC-CMFB)。 下面分别是主运放、偏置电路和开关电容共模反馈电路图 在设计时碰到的问题: 1、增益怎么测? 2、输出波形不平滑? 3、开关的时序频率设置多高? 解答: 1、先设计好主运放和偏置电路,使得运放的输出接近VDD/2,且主运放的管子都工作在饱和区,然后再参考何乐年的《模拟集成电路设计与仿真》仿增益。 2、增益仿完后,仿真瞬态,看电路的工作情况,于是将偏置电路上接Vb4与主运放断开,接到共模反馈上的Vbia上,然后就

qq_36686804的博客 1万+

图——最短路径Floyd算法

Floyd算法是解决求图中所有顶点到所有顶点的最短路径,时间复杂度是。Dijkstra算法是求从某个源点到其余各顶点的最短路径问题,时间复杂度是,如果求图中所有顶点到所有顶点的最短路径,需要再运行n次Dijkstra函数,时间复杂度也是。 Floyd算法与Dijkstra算法的比较: 1、Dijkstra算法更强调单源点查找路径的方式,比较符合正常思路,容易理解原理,但算法代码相对复杂。 2...

Revendell的博客 473

opencv+nvcodec实现视频硬解码

最近遇到一个新项目,AI推理在上,为了方便和节省成本的考虑决定研究下模块。根据官网的说法显卡具有独立的和模块,所以理论上和是独立互不干涉的。以前的项目都只是把显卡当成推理工具,没有将它的功能利用起来,本身也是一种浪费。事实真的有这么丝滑吗?看到这里,如果你真的觉得是白叫的那就真的是了,事实究竟如何,请听我娓娓道来。NVCODEC全称是 NVIDIA VIDEO CODEC,是NVIDIA为绝大多数显卡配置的硬件编解码单元。不一定是所有显卡都有,一般来讲越新的显卡硬件编解码就越强,支持的格式也就越新。

jiexijihe945的博客 1万+

从摄像头选型到PCB布线:搞懂MIPI CSI带宽计算,避免你的嵌入式项目翻车

本文详细解析了MIPI CSI带宽计算在嵌入式项目中的关键作用,从摄像头选型到PCB布线提供全流程指导。通过实际案例和计算公式,帮助工程师准确计算带宽需求,避免图像丢帧和系统崩溃问题,同时优化PCB设计确保信号完整性。

weixin_30533109的博客 376

C语言实现图的最短路径Floyd算法

Floyd算法直接使用二维数组求出所有顶点到所有顶点的最短路径。 D代表顶点到顶点的最短路径权值和的矩阵。 P代表对应顶点的最小路径的前驱矩阵。 以下程序在DEV C++中调试运行通过。 #include #define INFINITY 65535 typedef int VertexTy

KittyGirl 8949

模型预测控制(MPC)解析(三):多输入多输出系统

本文为阅读笔记,仅供学习交流使用!!! 在之前的文章中,为了简单起见,以单输入单输出系统为例介绍了MPC控制的实现方法。因为使用的是状态空间方程作为系统模型,这种方法可以轻松的扩展到多输入多输出系统中。 ...

行者无疆的博客 1万+

数据结构复习指导之图的最短路径(Dijkstra算法和Floyd算法)

本节是历年考查的重点。图的应用主要包括:最小生成(代价)树、最短路径、拓扑排序和关键路径。一般而言,这部分内容直接以算法设计题形式考查的可能性极小,而更多的是结合图的实例来考查算法的具体操作过程,读者必须学会手工模拟给定图的各个算法的执行过程。此外,还需掌握对给定模型建立相应的图去解决问题的方法。

心碎烤肠的博客 1313

OpenCV-Python实战(11)——OpenCV轮廓检测相关应用

在计算机视觉领域,轮廓通常指图像中对象边界的一系列点。因此,轮廓通常描述了对象边界的关键信息,包含了有关对象形状的主要信息,该信息可用于形状分析与对象检测和识别。在本文中,我们将学习如何利用获取到的轮廓,进行形状分析以及对象检测和识别。

盼小辉丶的博客 1万+

MobileFusion:基于结构重参数化的移动端红外可见光图像融合方法

MobileFusion提出了一种轻量化的红外与可见光图像融合框架,通过结构重参数化技术实现移动端实时部署。该方法包含可重参数多分支卷积(RepMBConv)、轻量化上下文感知注意力(LCAA)和重参数前馈网络(RepFFN)三大模块,在训练时保留多分支结构增强特征学习,推理时合并为单路算子提升效率。实验表明,MobileFusion在MSRS、FMB等数据集上实现了融合质量与推理速度的平衡,参数量仅4000,在边缘设备上也能高效运行,为资源受限场景提供了实用解决方案。代码已开源。

毕竟是Shy哥 140

图的应用——最短路径(Dijkstra 算法和 Floyd 算法)

参照2025年王道的数据结构考研复习指导书对Dijkstra算法求单源最短路径问题和Floyd算法求各顶点之间最短路径问题的过程进行了详细的介绍。

kusunoki的博客 7794

Unity之Timeline教程

Unity Timeline是Unity的一种时间轴编辑器工具,用于制作和管理游戏中的动画、剧情以及事件触发。它提供了直观的界面,使得开发者可以通过拖放操作轻松创建和编辑时间轴。Activation Track:用于控制物体的激活状态。可以在轨道上添加关键帧,控制物体的激活和非激活状态。Animation Track:用于处理物体的动画。可以在此轨道上添加关键帧,编辑物体的动画状态。Audio Track:用于处理场景中的音频。可以管理音频的播放、暂停、淡入淡出等操作。

TxNet 9447

求图中最短路径算法之Floyd-Warshall算法——C++实现

Floyed-Warshall算法使用动态规划的思想来计算图中所有节点对之间的最短路径,其运行时间复杂度为O(V^3),该算法的约束条件为图中不能包含权值之和为负的环,但可以包含权值为负的边。该算法相对于Dijkstra算法而言较难理解,建议感兴趣的可以阅读《算法导论》这本书中的第25章,里面分析的比较全面。动态规划思想运用范围比较广,对其深刻理解并能灵活运用比较难,所以在学习Floyed-War

疯狂的指针的博客 4190

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

图:最短路径—Floyd算法

松弛函数的作用就是判断是否经过某个顶点(边),可以缩短起点到终点的路径权值。算法又称之为费洛伊德算法,是解决给定的有权图中顶点之间的最短路径的一种算法,算法之前,我们先了解一个函数——松弛函数。由核心代码我们可以知道,,对于稠密图,效率高于。基本思想:递推产生一个。...

weixin_45652283的博客 2050

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Floyd算法,图的最短路径,c/c++描述

  求图中任意两顶点间的最短路径。可以参考这篇文章Floyd - Warshall(弗洛伊德算法) https://blog.youkuaiyun.com/yuewenyao/article/details/81021319   Dijkstra算法是求解单源点最短路径。依次把图中所有顶点作为源点,也可以得到图中任意两顶点间的最短路径。   Floyd算法的依据是这个公式dist[i][j] = min(dist[i][j] , dist[i][k] + dist[k][j])。   关于最短路径的几个关键知识点:  

zhangzhangkeji的博客 587

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

上一篇: 图的最短路径之Dijkstra算法
下一篇: 深入实践C++11智能指针
code_peak
博客等级 码龄5年 403粉丝 67原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值