bellman-ford

#include <iostream>
#include <math.h>
using namespace std;
int s,edgenum,nodenum;
const int max_edgenum=100;
const int max_nodenum=100;
struct Edge
{
	int u,v,cost;
}edge[max_edgenum];
int dis[max_nodenum];
bool Bellman_ford()
{
	for(int i=1;i<=nodenum;i++)
	{
		dis[i]=(i==s?0:INF);
	}
	for(int i=1;i<=nodenum-1;i++)
		for(int j=1;j<=edgenum;j++)
		{
			if(dis[edge[j].v]>dis[edge[j].u]+edge[j].cost)
				dis[edge[j].v]=dis[edge[j].u]+edge[j].cost;
		}
		for(int i=1;i<=edgenum;i++)
		if(dis[edge[i].v]>dis[edge[i].u]+edge[i].cost)
		{
			flag=0;return false;
		}
		return true;
}

#include<iostream>
using namespace std;
int P[100];
int D[100];
int W[100];
int U[100];
int V[100];
int m,n;
bool bellman_ford()
{
	for(int i=1;i<=n;i++)
	{
		D[i]=INF;
	}

	for(int i=1;i<=n-1;i++)
	for(int j=1;j<=m;j++)
	{
		if(D[V[j]]>D[U[j]]+W[j])
		{
			D[V[j]]>D[U[j]]+W[j];
			P[V[j]]=U[j];
		}
	}

	for(int j=1;j<=n-1;j++)
	{
		if(D[V[j]]>D[U[j]]+W[j])
			return false;
	}
	return true;
}

INF這裏還要學習，，，

Ford算法解決單源最短路問題，以及雙源最短路問題（因爲複雜度相同）

從權值正負來分析，Ford算法可以解決帶負權值的圖的最短路問題。

若最短路存在，最短路徑中一定不存在負環。即經過n-1條邊。

算法思想是，進行n-1輪鬆弛，每輪鬆弛中更新所有邊；n-1輪鬆弛後仍可更新邊，說明含有負環。

附：百度百科上還有更簡練的代碼實現，每輪鬆弛操作後會判斷是否收斂。