Bellman Ford 算法（简单实现）

我们已经介绍了 Bellman Ford 并在这里讨论了实施。
输入：图形和源顶点src
输出：从src到所有顶点的最短距离。如果存在负重量周期，则不计算最短距离，报告负重量周期。
1)这一步将源到所有顶点的距离初始化为无穷大，到源自身的距离初始化为 0。创建一个大小为 |V| 的数组 dist[]除了 dist[src] 其中 src 是源顶点之外，所有值都为无穷大。
2)这一步计算最短距离。跟随 |V|-1 次，其中 |V|是给定图中的顶点数。
….. a)对每个边 uv 执行以下操作
………………如果dist[v] > dist[u] + 边uv的权重，则更新dist[v]
………………….dist[v] = dist[u] + 边 uv 的权重
3)此步骤报告图中是否存在负权重循环。对每个边缘 uv 执行以下操作
……如果 dist[v] > dist[u] + 边 uv 的权重，则“图包含负权重循环”
第 3 步的想法是，如果图不包含负权重循环，则第 2 步保证最短距离。如果我们再一次遍历所有边并为任何顶点获得一条更短的路径，那么存在负权重循环
例子
让我们通过以下示例图来理解算法。图像取自此来源。
让给定的源顶点为 0。将所有距离初始化为无穷大，除了到源本身的距离。图中的顶点总数为 5，因此所有边都必须处理 4 次。

让所有边按以下顺序处理：(B, E), (D, B), (B, D), (A, B), (A, C), (D, C), (B, C) , (E, D)。第一次处理所有边时，我们得到以下距离。中的第一行显示初始距离。第二行显示处理边 (B, E)、(D, B)、(B, D) 和 (A, B) 时的距离。第三行显示处理 (A, C) 时的距离。第四行显示何时处理（D，C），（B，C）和（E，D）。

第一次迭代保证给出最多 1 条边长的所有最短路径。当第二次处理所有边时，我们得到以下距离（最后一行显示最终值）。

第二次迭代保证给出最多 2 条边长的所有最短路径。该算法将所有边再处理 2 次。第二次迭代后距离最小化，因此第三次和第四次迭代不会更新距离。

C++

// A C++ program for Bellman-Ford's single source
// shortest path algorithm.
#include 
using namespace std;
 
// The main function that finds shortest
// distances from src to all other vertices
// using Bellman-Ford algorithm. The function
// also detects negative weight cycle
// The row graph[i] represents i-th edge with
// three values u, v and w.
void BellmanFord(int graph[][3], int V, int E,
                 int src)
{
    // Initialize distance of all vertices as infinite.
    int dis[V];
    for (int i = 0; i < V; i++)
        dis[i] = INT_MAX;
 
    // initialize distance of source as 0
    dis[src] = 0;
 
    // Relax all edges |V| - 1 times. A simple
    // shortest path from src to any other
    // vertex can have at-most |V| - 1 edges
    for (int i = 0; i < V - 1; i++) {
 
        for (int j = 0; j < E; j++) {
            if (dis[graph[j][0]] != INT_MAX && dis[graph[j][0]] + graph[j][2] <
                               dis[graph[j][1]])
                dis[graph[j][1]] =
                  dis[graph[j][0]] + graph[j][2];
        }
    }
 
    // check for negative-weight cycles.
    // The above step guarantees shortest
    // distances if graph doesn't contain
    // negative weight cycle.  If we get a
    // shorter path, then there is a cycle.
    for (int i = 0; i < E; i++) {
        int x = graph[i][0];
        int y = graph[i][1];
        int weight = graph[i][2];
        if (dis[x] != INT_MAX &&
                   dis[x] + weight < dis[y])
            cout << "Graph contains negative"
                    " weight cycle"
                 << endl;
    }
 
    cout << "Vertex Distance from Source" << endl;
    for (int i = 0; i < V; i++)
        cout << i << "\t\t" << dis[i] << endl;
}
 
// Driver program to test above functions
int main()
{
    int V = 5; // Number of vertices in graph
    int E = 8; // Number of edges in graph
 
    // Every edge has three values (u, v, w) where
    // the edge is from vertex u to v. And weight
    // of the edge is w.
    int graph[][3] = { { 0, 1, -1 }, { 0, 2, 4 },
                       { 1, 2, 3 }, { 1, 3, 2 },
                       { 1, 4, 2 }, { 3, 2, 5 },
                       { 3, 1, 1 }, { 4, 3, -3 } };
 
    BellmanFord(graph, V, E, 0);
    return 0;
}

Java

// A Java program for Bellman-Ford's single source
// shortest path algorithm.
 
class GFG
{
 
// The main function that finds shortest
// distances from src to all other vertices
// using Bellman-Ford algorithm. The function
// also detects negative weight cycle
// The row graph[i] represents i-th edge with
// three values u, v and w.
static void BellmanFord(int graph[][], int V, int E,
                int src)
{
    // Initialize distance of all vertices as infinite.
    int []dis = new int[V];
    for (int i = 0; i < V; i++)
        dis[i] = Integer.MAX_VALUE;
 
    // initialize distance of source as 0
    dis[src] = 0;
 
    // Relax all edges |V| - 1 times. A simple
    // shortest path from src to any other
    // vertex can have at-most |V| - 1 edges
    for (int i = 0; i < V - 1; i++)
    {
 
        for (int j = 0; j < E; j++)
        {
            if (dis[graph[j][0]] != Integer.MAX_VALUE && dis[graph[j][0]] + graph[j][2] <
                            dis[graph[j][1]])
                dis[graph[j][1]] =
                dis[graph[j][0]] + graph[j][2];
        }
    }
 
    // check for negative-weight cycles.
    // The above step guarantees shortest
    // distances if graph doesn't contain
    // negative weight cycle. If we get a
    // shorter path, then there is a cycle.
    for (int i = 0; i < E; i++)
    {
        int x = graph[i][0];
        int y = graph[i][1];
        int weight = graph[i][2];
        if (dis[x] != Integer.MAX_VALUE &&
                dis[x] + weight < dis[y])
            System.out.println("Graph contains negative"
                    +" weight cycle");
    }
 
    System.out.println("Vertex Distance from Source");
    for (int i = 0; i < V; i++)
        System.out.println(i + "\t\t" + dis[i]);
}
 
// Driver code
public static void main(String[] args)
{
    int V = 5; // Number of vertices in graph
    int E = 8; // Number of edges in graph
 
    // Every edge has three values (u, v, w) where
    // the edge is from vertex u to v. And weight
    // of the edge is w.
    int graph[][] = { { 0, 1, -1 }, { 0, 2, 4 },
                    { 1, 2, 3 }, { 1, 3, 2 },
                    { 1, 4, 2 }, { 3, 2, 5 },
                    { 3, 1, 1 }, { 4, 3, -3 } };
 
    BellmanFord(graph, V, E, 0);
    }
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program for Bellman-Ford's
# single source shortest path algorithm.
from sys import maxsize
 
# The main function that finds shortest
# distances from src to all other vertices
# using Bellman-Ford algorithm. The function
# also detects negative weight cycle
# The row graph[i] represents i-th edge with
# three values u, v and w.
def BellmanFord(graph, V, E, src):
 
    # Initialize distance of all vertices as infinite.
    dis = [maxsize] * V
 
    # initialize distance of source as 0
    dis[src] = 0
 
    # Relax all edges |V| - 1 times. A simple
    # shortest path from src to any other
    # vertex can have at-most |V| - 1 edges
    for i in range(V - 1):
        for j in range(E):
            if dis[graph[j][0]] + \
                   graph[j][2] < dis[graph[j][1]]:
                dis[graph[j][1]] = dis[graph[j][0]] + \
                                       graph[j][2]
 
    # check for negative-weight cycles.
    # The above step guarantees shortest
    # distances if graph doesn't contain
    # negative weight cycle. If we get a
    # shorter path, then there is a cycle.
    for i in range(E):
        x = graph[i][0]
        y = graph[i][1]
        weight = graph[i][2]
        if dis[x] != maxsize and dis[x] + \
                        weight < dis[y]:
            print("Graph contains negative weight cycle")
 
    print("Vertex Distance from Source")
    for i in range(V):
        print("%d\t\t%d" % (i, dis[i]))
 
# Driver Code
if __name__ == "__main__":
    V = 5 # Number of vertices in graph
    E = 8 # Number of edges in graph
 
    # Every edge has three values (u, v, w) where
    # the edge is from vertex u to v. And weight
    # of the edge is w.
    graph = [[0, 1, -1], [0, 2, 4], [1, 2, 3],
             [1, 3, 2], [1, 4, 2], [3, 2, 5],
             [3, 1, 1], [4, 3, -3]]
    BellmanFord(graph, V, E, 0)
 
# This code is contributed by
# sanjeev2552

C#

// C# program for Bellman-Ford's single source
// shortest path algorithm.
using System;
     
class GFG
{
 
// The main function that finds shortest
// distances from src to all other vertices
// using Bellman-Ford algorithm. The function
// also detects negative weight cycle
// The row graph[i] represents i-th edge with
// three values u, v and w.
static void BellmanFord(int [,]graph, int V,
                        int E, int src)
{
    // Initialize distance of all vertices as infinite.
    int []dis = new int[V];
    for (int i = 0; i < V; i++)
        dis[i] = int.MaxValue;
 
    // initialize distance of source as 0
    dis[src] = 0;
 
    // Relax all edges |V| - 1 times. A simple
    // shortest path from src to any other
    // vertex can have at-most |V| - 1 edges
    for (int i = 0; i < V - 1; i++)
    {
        for (int j = 0; j < E; j++)
        {
            if (dis[graph[j, 0]] = int.MaxValue && dis[graph[j, 0]] + graph[j, 2] <
                dis[graph[j, 1]])
                dis[graph[j, 1]] =
                dis[graph[j, 0]] + graph[j, 2];
        }
    }
 
    // check for negative-weight cycles.
    // The above step guarantees shortest
    // distances if graph doesn't contain
    // negative weight cycle. If we get a
    // shorter path, then there is a cycle.
    for (int i = 0; i < E; i++)
    {
        int x = graph[i, 0];
        int y = graph[i, 1];
        int weight = graph[i, 2];
        if (dis[x] != int.MaxValue &&
                dis[x] + weight < dis[y])
            Console.WriteLine("Graph contains negative" +
                                        " weight cycle");
    }
 
    Console.WriteLine("Vertex Distance from Source");
    for (int i = 0; i < V; i++)
        Console.WriteLine(i + "\t\t" + dis[i]);
}
 
// Driver code
public static void Main(String[] args)
{
    int V = 5; // Number of vertices in graph
    int E = 8; // Number of edges in graph
 
    // Every edge has three values (u, v, w) where
    // the edge is from vertex u to v. And weight
    // of the edge is w.
    int [,]graph = {{ 0, 1, -1 }, { 0, 2, 4 },
                    { 1, 2, 3 }, { 1, 3, 2 },
                    { 1, 4, 2 }, { 3, 2, 5 },
                    { 3, 1, 1 }, { 4, 3, -3 }};
 
    BellmanFord(graph, V, E, 0);
}
}
 
// This code is contributed by Princi Singh

Javascript

    
// Javascript program for Bellman-Ford's single source
// shortest path algorithm.
 
// The main function that finds shortest
// distances from src to all other vertices
// using Bellman-Ford algorithm. The function
// also detects negative weight cycle
// The row graph[i] represents i-th edge with
// three values u, v and w.
function BellmanFord(graph, V, E, src)
{
    // Initialize distance of all vertices as infinite.
    var dis = Array(V).fill(1000000000);
 
    // initialize distance of source as 0
    dis[src] = 0;
 
    // Relax all edges |V| - 1 times. A simple
    // shortest path from src to any other
    // vertex can have at-most |V| - 1 edges
    for (var i = 0; i < V - 1; i++)
    {
        for (var j = 0; j < E; j++)
        {
            if ((dis[graph[j][0]] + graph[j][2]) < dis[graph[j][1]])
                dis[graph[j][1]] = dis[graph[j][0]] + graph[j][2];
        }
    }
 
    // check for negative-weight cycles.
    // The above step guarantees shortest
    // distances if graph doesn't contain
    // negative weight cycle. If we get a
    // shorter path, then there is a cycle.
    for (var i = 0; i < E; i++)
    {
        var x = graph[i][0];
        var y = graph[i][1];
        var weight = graph[i][2];
        if ((dis[x] != 1000000000) &&
                (dis[x] + weight < dis[y]))
            document.write("Graph contains negative" +
                                        " weight cycle<br>");
    }
 
    document.write("Vertex Distance from Source<br>");
    for (var i = 0; i < V; i++)
        document.write(i + "   " + dis[i] + "<br>");
}
 
// Driver code
var V = 5; // Number of vertices in graph
var E = 8; // Number of edges in graph
 
// Every edge has three values (u, v, w) where
// the edge is from vertex u to v. And weight
// of the edge is w.
var graph = [[ 0, 1, -1 ], [ 0, 2, 4 ],
                [ 1, 2, 3 ], [ 1, 3, 2 ],
                [ 1, 4, 2 ], [ 3, 2, 5 ],
                [ 3, 1, 1 ], [ 4, 3, -3 ]];
BellmanFord(graph, V, E, 0);
 
// This code is contributed by importantly.

输出：

Vertex Distance from Source
0        0
1        -1
2        2
3        -2
4        1

时间复杂度： O(VE)
此实现由PrateekGupta10建议

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。