floyd算法(加记录路径)

floyd算法可以计算任意两点之间的最短距离,同时可以处理Dijkstra不能处理的带负权边的图

算法思想

   从第一个点开始遍历,依次当作中间点k,遍历所有边,看是否有两个点的距离小于存在这个中间点时的距离,若小于,则更新这两个点的距离,同时更新路径

算法实现

两个矩阵,一个记录最短距离dis[i][j],一个记录路径path[i][j]

三层循环,最外层循环中间点,从1到n遍历,内两层分别遍历所有点,如果dis[i][k]+dis[k][j] < dis[i][j],则更新dis[i][j]为dis[i][k]+dis[k][j],更新path[i][j]为k

时间复杂度O(n∧3)

板子:

const int maxx=1e3+100;
const int INF=1e9;
int dis[maxx][maxx];
int path[maxx][maxx];
void init(int n)
{
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++){
            dis[i][j]=-INF;
            path[i][j]=-1;
        }
    }
}
void floyd(int n)
{
    for(int k=1; k<=n; k++){
        for(int i=1; i<=n; i++){
            for(int j=1; j<=n; j++){
                if(dis[i][k] + dis[k][j] < dis[i][j]){
                    dis[i][j]=dis[i][k] + dis[k][j];
                    path[i][j]=k;
                }
            }
        }
    }
}

 

<think>好的,我现在需要帮助用户了解如何用C++实现Floyd算法记录最短路径。首先,我应该回忆一下Floyd算法的基本概念和实现步骤。Floyd算法是一种动态规划算法,用于计算图中所有顶点对之间的最短路径。它的时间复杂度是O(),适用于包含负权边但不含负权环的图。 用户提到的是如何记录路径,而不仅仅是计算最短距离。通常,Floyd算法实现中会使用一个距离矩阵来存储各顶点之间的最短距离,但为了记录路径,还需要一个路径矩阵(通常称为next矩阵),用于记录从顶点i到顶点j的最短路径中,i之后的下一个顶点。 接下来,我需要考虑如何在C++中实现这一点。首先,初始化距离矩阵和路径矩阵。距离矩阵初始时,各边的权值就是输入的权值,如果两个顶点之间没有直接边相连,则设为无穷大。路径矩阵next初始时,如果i和j之间有边,则next[i][j] = j,否则可能需要设为-1或其他标识符。 然后,Floyd算法的核心是三重循环,遍历每个中间顶点k,以及所有顶点对i和j。如果通过k作为中间点,i到j的路径更短,则更新距离矩阵和路径矩阵。具体来说,如果dist[i][k] + dist[k][j] < dist[i][j],则更新dist[i][j]为这个更小的值,并更新next[i][j]为next[i][k],因为从i到j的最短路径现在经过k,所以i的下一个节点应该是i到k路径上的下一个节点。 在代码实现中,需要注意图的顶点编号是否从0开始。通常,在C++中,顶点从0到n-1编号比较方便。然后,如何输出路径呢?可以编写一个递归函数,通过next矩阵来回溯路径。例如,从i开始,找到next[i][j],然后递归处理next[next[i][j]][j],直到到达j为止。 现在,我需要检查用户提供的引用内容。引用[1]和[4]提到Floyd算法是动态规划的,引用[4]还提到使用next矩阵来记录路径。这与我之前的思路一致。因此,实现时需要初始化next矩阵,并在每次更新距离时同步更新next矩阵。 可能的错误点包括:初始化路径矩阵时是否正确处理了直接相连的边,以及在更新路径时是否正确指向中间节点。此外,处理无穷大值时需要注意数据类型的选择,比如使用INT_MAX或一个足够大的数,并在计算时防止溢出。 最后,编写示例代码时,需要包含输入图的处理,初始化矩阵,执行Floyd算法,并展示如何输出路径。例如,用户输入顶点数和邻接矩阵后,程序计算最短路径矩阵和路径矩阵,然后通过路径矩阵递归输出具体路径。 总结步骤: 1. 定义图的顶点数和邻接矩阵。 2. 初始化距离矩阵和路径矩阵。 3. 三重循环更新距离和路径矩阵。 4. 编写路径输出函数。 5. 测试代码并处理边界情况,如不可达的顶点。</think>以下是用C++实现Floyd算法记录最短路径的详细步骤和代码示例: ### 一、核心实现思路 1. **动态规划思想**:通过中间节点逐步优化所有顶点对的最短路径[^4] 2. **路径记录**:使用二维数组`next`存储路径信息,其中`next[i][j]`表示从$i$到$j$的最短路径的第一个中转节点[^4] 3. **三重循环**:时间复杂度$O(n^3)$,空间复杂度$O(n^2)$[^2] ### 二、完整代码实现 ```cpp #include <iostream> #include <vector> #include <climits> using namespace std; const int INF = INT_MAX; void printPath(int i, int j, const vector<vector<int>>& next) { if (next[i][j] == -1) { cout << "No path"; return; } cout << i; while (i != j) { i = next[i][j]; cout << " -> " << i; } } void floydWarshall(vector<vector<int>>& graph, int n) { vector<vector<int>> dist(n, vector<int>(n)); vector<vector<int>> next(n, vector<int>(n, -1)); // 初始化 for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { dist[i][j] = graph[i][j]; if (graph[i][j] != INF && i != j) { next[i][j] = j; } } } // Floyd核心算法 for (int k = 0; k < n; ++k) { for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { if (dist[i][k] != INF && dist[k][j] != INF && dist[i][j] > dist[i][k] + dist[k][j]) { dist[i][j] = dist[i][k] + dist[k][j]; next[i][j] = next[i][k]; } } } } // 输出路径 cout << "Path from 0 to 3: "; printPath(0, 3, next); cout << "\nDistance: " << dist[0][3] << endl; } int main() { int n = 4; vector<vector<int>> graph = { {0, 3, INF, 5}, {2, 0, INF, 4}, {INF, 1, 0, INF}, {INF, INF, 2, 0} }; floydWarshall(graph, n); return 0; } ``` ### 三、关键点解析 1. **路径记录机制**: - `next[i][j]`存储的是$i$到$j$路径上的第一个中转节点 - 更新规则:当发现更短路径时,`next[i][j] = next[i][k]`[^4] 2. **路径重构算法**: ```cpp void printPath(int i, int j, ...) { while (i != j) { i = next[i][j]; cout << " -> " << i; } } ``` 3. **输入矩阵处理**: - 使用`INF`表示不可达路径 - 对角线元素初始化为0(顶点到自身) ### 四、算法验证 示例输入矩阵: $$ \begin{pmatrix} 0 & 3 & ∞ & 5 \\ 2 & 0 & ∞ & 4 \\ ∞ & 1 & 0 & ∞ \\ ∞ & ∞ & 2 & 0 \end{pmatrix} $$ 输出结果: ``` Path from 0 to 3: 0 -> 1 -> 3 Distance: 7 ```
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值