bellman ford java_Bellman-Ford算法

Dijkstra算法没办法处理带有负权的图，所以这时候就需要Bellman-Ford算法了，在假设途中没有负权回路(回路的权值和为负，即回路中负权的值大于其他几遍的权值和)可以采用Bellman-Ford算法，但是该算法的时间复杂度为O(V*E),效率较低

1.初始化：将除源点外的所有顶点的最短距离估计值 d[v] ——>+∞, d[s]——>0;

2.迭代求解：反复对边集E中的每条边进行松弛操作，使得顶点集V中的每个顶点v的最短距离估计值逐步逼近其最短距离；(运行|v|-1次)

3.检验负权回路：判断边集E中的每一条边的两个端点是否收敛。如果存在未收敛的顶点，则算法返回false，表明问题无解；否则算法返回true，并且从源点可达的顶点v的最短距离保存在 d[v]中。

#include

#include

using namespace std;

const int maxnum=100; //最大边数

const int maxint=9999; //源点和某点不可达时的距离

//有向边的结构体

typedef struct Edge

{

int Start; //有向边边的起始点

int End; //有向边的终点

int Weight;//边的权重

}Edge;

Edge edge[maxnum];//有向边的数组

int dist[maxnum]; //距离数组

//节点的数目、边的数目、源节点的下标

int nodenum,edgenum,source;

//初始化函数

void Init()

{

cin>>nodenum>>edgenum>>source;

for(int i=1;i<=nodenum;i++)

dist[i]=maxint;

dist[source]=0;

for(int i=1;i<=edgenum;i++)

{

cin >> edge[i].Start >> edge[i].End >> edge[i].Weight;

if(source==edge[i].Start)

{

dist[edge[i].End]=edge[i].Weight;

}

}

}

//松弛函数

void Relax(int Start,int End,int Weight)

{

if(dist[End]>dist[Start]+Weight)

dist[End]=dist[Start]+Weight;

}

//贝尔曼福特函数

bool Bellman_Ford()

{

for(int i=1;i<=nodenum-1;i++)

{

for(int j=1;j<=edgenum;j++)

{

Relax(edge[j].Start,edge[j].End,edge[j].Weight);

}

}

bool flag=1;

for(int i=1;i<=edgenum;i++)

{

//判断是否存在负回路

if(dist[edge[i].End]>dist[edge[i].Start]+edge[i].Weight)

{

flag=0;

break;

}

}

return flag;

}

int main()

{

freopen("out.txt","r",stdin);//打开txt

Init();

if(Bellman_Ford())

{

for(int i=1;i

cout<

}

return 0;

}