【算法导论学习笔记】多源最短路径 矩阵乘法解决 Floyd-Warshall算法解决

多源最短路径

Problem: Given a directed graph G=(V, E), and a weight function w: E∈R, for each pair of vertices u, v, compute the shortest path weight δ(u, v), and a shortest path if exists.

Output: a V×V matrix D=(dij), where dij contains the weight of a shortest path from vertex i to vertex j.

解决办法：
(1) 矩阵乘法
(2) Floyd-Warshall算法

矩阵乘法

图用邻接矩阵来表示

这里讲的顶点对之间的最短路径是基于动态规划在图中的实现。每一个循环都类似矩阵乘法，因此这个算法看起来就像是一直在做矩阵乘法。

在这里我们用邻接矩阵表示法来表示一个图，因为相对邻接表来说，邻接矩阵表示要容易些，并且采用自底而下的算法来计算最短路径权重。

#include <iostream>
using namespace std;

int M[5][5] = {
    {0, 3, 8, 9999, -4},
    {9999, 0, 9999, 1, 7},
    {9999, 4, 0, 9999, 9999},
    {2, 9999, -5, 0, 9999},
    {9999, 9999, 9999, 6, 0}};
int dis[5][5];

int main()
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            dis[i][j] = M[i][j];
        }
    }
    int count = 0;
    while (count < 4)
    {
        for (int i = 0; i < 5; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                for (int k = 0; k < 5; k++)
                {
                    if (dis[i][k] + M[k][j] < dis[i][j])
                    {
                        dis[i][j] = dis[i][k] + M[k][j];
                    }
                }
            }
        }
        count++;
        for (int i = 0; i < 5; i++)
        {
            for (int j = 0; j < 5; j++)
            {
                cout << dis[i][j] << ' ';
            }
            cout << endl;
        }
        cout << endl;
    }
    return 0;
}

Floyd-Warshall算法

1.定义概览

Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。

2.算法原理

Floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在）

从任意节点i到任意节点j的最短路径不外乎2种可能，1是直接从i到j，2是从i经过若干个节点k到j。所以，我们假设Dis(i,j)为节点u到节点v的最短路径的距离，对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，证明从i到k再到j的路径比i直接到j的路径短，我们便设置Dis(i,j) = Dis(i,k) + Dis(k,j)，这样一来，当我们遍历完所有节点k，Dis(i,j)中记录的便是i到j的最短路径的距离。

使用这个算法，我们要准备两个矩阵
（1）第一个矩阵为图的邻接矩阵
（2）第二个矩阵是Path，用于存放任意一对定点之间的最短路径Path。

对于每一个顶点v，和任一顶点对(i,j),i != j, v != i, v != j,如果每个A[i][j] > A[i][v] + A[v][j],则将A[i][j]更新为A[i][v] + A[v][j]的值，并且将Path[i][j]改为v。

【最短路径Floyd算法】 https://www.bilibili.com/video/BV1LE411R7CS/?share_source=copy_web&vd_source=8116e2c6d66e09abcb77ce6e2d37b888

#include <iostream>
using namespace std;

int dis[5][5] = {
    {0, 3, 8, 9999, -4},
    {9999, 0, 9999, 1, 7},
    {9999, 4, 0, 9999, 9999},
    {2, 9999, -5, 0, 9999},
    {9999, 9999, 9999, 6, 0}};
int path[5][5];

void initPath()
{
    for (int i = 0; i < 5; i++)
        for (int j = 0; j < 5; j++)
            path[i][j] = -1;
}

int main()
{
    initPath();
    for (int k = 0; k < 5; k++) // 先过第k个顶点
    {
        // 经过k点时，遍历每一对点
        for (int i = 0; i < 5; i++)
        {
            if (i == k)
                continue;
            for (int j = 0; j < 5; j++)
            {
                if (j == i || j == k)
                    continue;
                if (dis[i][j] > dis[i][k] + dis[k][j])
                {
                    dis[i][j] = dis[i][k] + dis[k][j];
                    path[i][j] = k;
                }
            }
        }
    }
    // 打印最后的结果
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            cout << dis[i][j] << ' ';
        }
        cout << endl;
    }
    return 0;
}