Bellman-Ford算法也是求图的单源点最短路径问题。

不同于Dijkstra算法的是它能应用于带负权值边的图，并且可以判断图中是否有负循环。

该算法的时间复杂度为O(VE) more than Dijkstra算法。

V为顶点个数

dist[V]数组记录所有顶点到源点的距离

执行V-1次循环

  每次循环对每一条边执行如下操作

    if(dist[v]>dist[u]+weight of edge uv)

      dist[v]=dist[u]+weight;

执行第V次以上操作，若dist数组有改动则图中有负循环

#include <iostream>
#include <vector>

using namespace std;

struct Edge {
	int src, dest, weight;
	Edge(int s, int d, int w) : src(s), dest(d), weight(w) { }
};
struct Graph {
	int V;
	vector<Edge> edge;
public:
	Graph(int v) : V(v) { }
	void addEdge(int src, int dest, int weight);
	void BellmanFord(int src);
};

void Graph::addEdge(int src, int dest, int weight)
{
	edge.push_back(Edge(src, dest, weight));
}

void printSolution(vector<int> & dist)
{
	cout << "Vertex   Distance from Source" << endl;
	for (int i = 0;i < dist.size();i++)
		cout << i << "\t\t" << dist[i] << endl;
}

void Graph::BellmanFord(int src)
{
	vector<int> dist(V, INT_MAX);
	dist[src] = 0;

	for (int i = 1;i < V;i++)
	{
		for (Edge e : edge)
		{
			int u = e.src;
			int v = e.dest;
			int weight = e.weight;
			if (dist[u] != INT_MAX && dist[u] + weight < dist[v])
				dist[v] = dist[u] + weight;
		}
	}

	for (Edge e : edge)
	{
		int u = e.src;
		int v = e.dest;
		int weight = e.weight;
		if (dist[u] != INT_MAX && dist[u] + weight < dist[v])
		{
			cout << "Graph contains negetive weight cycle" << endl;
			break;
		}
	}
	printSolution(dist);

	return;
}

int main()
{

	Graph graph(5);

	graph.addEdge(0, 1, -1);
	graph.addEdge(0, 2, 4);
	graph.addEdge(1, 2, 3);
	graph.addEdge(1, 3, 2);
	graph.addEdge(1, 4, 2);
	graph.addEdge(3, 2, 5);
	graph.addEdge(3, 1, 1);
	graph.addEdge(4, 3, -3);

	graph.BellmanFord(3);

	return 0;
}