📜  Bellman Ford算法(简单实现)

📅  最后修改于: 2021-04-27 20:37:18             🧑  作者: Mango

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的权重，则“图形包含负权重循环”

##### 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``````

##### PHP

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