Bellman-Ford算法

思想

Dijkstra算法虽然好，但是它不能解决带有负权边（边的权值为负数）的图。

接下来学习一种无论在思想上还是在代码实现上都可以称为完美的最短路径算法：Bellman-Ford算法。

Bellman-Ford算法非常简单，核心代码四行，可以完美的解决带有负权边的图。

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;              
             

在一个含有n个顶点的图中，任意两点之间的最短路径最多包含n-1条边，最短路径中不可能包含回路。

　　因为最短路径是一个不包含回路的简单路径，回路分为正权回路(回路权值之和为正)和负权回路(回路权值之和为负)。如果最短路径中包含正权回路，那么去掉这个回路，一定可以得到更短的路径；如果最短路径中包含负权回路，那么肯定没有最短路径，因为每多走一次负权回路就可以得到更短的路径. 因此最短路径肯定是一个不包含回路的最短路径，即最多包含n-1条边。

Bellman-Ford算法的主要思想：

　　首先dis数组初始化顶点u到其余各个顶点的距离为∞，dis[u] = 0。

　　然后每轮对输入的所有边进行松弛，更新dis数组，至多需要进行n-1次就可以求出顶点u到其余各顶点的最短路径（因为任意两点之间的最短路径最多包含n-1条边，所以只需要n-1轮就行）。

一句话概括Bellman-Ford算法就是：对所有边进行n-1次“松弛”操作。

此外，Bellman-Ford算法可以检测一个图是否有负权回路。如果已经进行了n-1轮松弛之后，仍然存在

if(dis[edge[j].v] > dis[edge[j].u] + edge[j].cost) //松弛（顺序一定不能反~）  
   dis[edge[j].v] = dis[edge[j].u] + edge[j].cost; 

的情况，也就是说在进行n-1轮之后，仍然可以继续成功松弛，那么这个图一定存在负权回路。

关键代码如下：

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;        

bool flag = 1; //判断是否含有负权回路  
for(int i = 1; i <= edgenum; ++i)  
    if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)  
    {  
        flag = 0;  
        break;  
    } 

return flag; 

 

显然，算法复杂度为O（NM），比Dijkstra算法还高，当然可以进行优化。

在实际操作中，Bellman-Ford算法经常会在没有达到n-1轮松弛前就已经计算出最短路，上面已经说过，n-1其实是最大轮回次数。

因此可以添加一个变量check用来标记数组dis在本轮松弛中是否发生了变化，若没有变化，则提前跳出循环。

for(int i = 1; i <= nodenum - 1; ++i)  
{
	bool check=0;
	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;  
        	check=1;
            } 
        }  
        if(!check)
    	    break;
} 
bool flag = 1; //判断是否含有负权回路  
for(int i = 1; i <= edgenum; ++i)  
{
	if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)  
	{  
		flag = 0;  
		break;  
	} 
}
return flag; 

模板

#include<iostream>  
#include<cstdio>  
using namespace std;  
   
#define MAX 0x3f3f3f3f  
#define N 1010  
int nodenum, edgenum, original; //点，边，起点  
   
struct Edge //边  
{  
    int u, v;  
    int cost;  
};  
   
Edge edge[N];  
int dis[N], pre[N];  
   
bool Bellman_Ford()  
{  
    for(int i = 1; i <= nodenum; ++i) //初始化  
        dis[i] = (i == original ? 0 : MAX);  
    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;  
                pre[edge[j].v] = edge[j].u;  
            }  
    bool flag = 1; //判断是否含有负权回路  
    for(int i = 1; i <= edgenum; ++i)  
        if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)  
        {  
            flag = 0;  
            break;  
        }  
        return flag;  
}  
   
void print_path(int root) //打印最短路的路径（反向）  
{  
    while(root != pre[root]) //前驱  
    {  
        printf("%d-->", root);  
        root = pre[root];  
    }  
    if(root == pre[root])  
        printf("%d\n", root);  
}  
   
int main()  
{  
    scanf("%d%d%d", &nodenum, &edgenum, &original);  
    pre[original] = original;  
    for(int i = 1; i <= edgenum; ++i)  
    {  
        scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].cost);  
    }  
    if(Bellman_Ford())  
        for(int i = 1; i <= nodenum; ++i) //每个点最短路  
        {  
            printf("%d\n", dis[i]);  
            printf("Path:");  
            print_path(i);  
        }  
    else  
        printf("have negative circle\n");  
    return 0;  
}  

例题1:POJ 3259 Wormholes

题意

J是狂热的时间旅行者，他在探索他的农场里田地的时候发现许多虫洞，他从一个田地到另一个田地可以通过走路或者是虫洞，如果通过虫洞的话，花的时间会减少，判断他能否碰到他自己~~~

输入
第1行：一个整数F表示F个农场，接下来所有行是F个农场说明。

对于每个农场：

      第1行：分别是三个空格隔开的整数：N，M和W，有 N 块田地，M条田地之间的道路，W是田地之间的虫洞的数量
      第2行到M+1行：三个空格分开的数字（S,E,T），描述双向路径，S到E且花费T秒。
      第M+2到M+W+1行：三个空格分开的数字（S,E,T），描述单向路径，S到E且回溯T秒。

输出
F行，每行代表一个农场
每个农场单独的一行，” YES”表示能满足要求，”NO”表示不能满足要求。

代码

#include<iostream>
#include<string.h>
using namespace std;


int f;//农场数 

/*对于每一个农场的参数如下 */
const int MAXN=505;//最多的田地块数 
const int MAXPATH=5500;//最多的道路数，包括普通道路和虫洞 
int n,m,w;//输入的n个田地，m条双向道路，w个虫洞 
int all;  //总道路数，包括普通道路和虫洞
int dis[MAXN];  //某一田地到各点的距离

struct Edge //边，即道路 
{  
	int u, v;  
	int cost;  
}path[MAXPATH]; 

/*每一个农场的信息输入*/ 
void input()
{
	int u,v,cost;
	cin>>n>>m>>w;
	all=0;
 	/*普通道路*/
	for(int i=0;i<m;i++)
	{
		cin>>u>>v>>cost;
		path[all].u = u;
		path[all].v = v;
		path[all++].cost = cost;
		path[all].u = v;
		path[all].v = u;
		path[all++].cost = cost;
	} 
 	/*虫洞道路*/
	for(int i=0;i<w;i++)
	{
		cin>>u>>v>>cost;
		path[all].u = u;
		path[all].v = v;
		path[all++].cost = -cost;
	} 
} 

/*bellman ford算法*/
bool bellman()
{
	memset(dis,0x3f,sizeof(dis));     
	dis[path[0].u]=0;    

	/*松弛*/
	bool flag;
	for(int i=1;i<=n-1;i++)
	{
		flag=false;
		for(int j=0;j<all;j++)
		{
			if(dis[path[j].v] > dis[path[j].u] +path[j].cost)         
			{                                                              
				dis[path[j].v] = dis[path[j].u] +path[j].cost;
				flag=true;
			}
		}
		if(!flag)
			break;
	}

	/*找负环*/
	for(int k=0;k<all;k++)                                          
	{
		if(dis[path[k].v] > dis[path[k].u] +path[k].cost)                
			return true;
	}
	return false;
}

int main()
{
	while(cin>>f)
	{
		while(f--)
		{
			input();
			if(bellman())
				cout<<"YES"<<endl;
			else
				cout<<"NO"<<endl;
		}
	}
	return 0;
}

例题2:poj1860 Currency Exchange 

题意

有多种汇币，汇币之间可以交换，这需要手续费，当你用100A币交换B币时，A到B的汇率是29.75，手续费是0.39，那么你可以得到(100 - 0.39) * 29.75 = 2963.3975 B币。问s币的金额经过交换最终得到的s币金额数能否增加，货币的交换是可以重复多次的，所以我们需要找出是否存在正权回路，且最后得到的s金额是增加的。怎么找正权回路呢？（正权回路：在这一回路上，顶点的权值能不断增加即能一直进行松弛）

思路

关键在于反向利用Bellman-Ford算法
单源最短路径算法，因为题目可能存在负边，所以用Bellman Ford算法，这题需要改进一下用来求正环。

一种货币就是图上的一个点，每一种“兑换方式”是一条边，一个“兑换点”的两个“兑换方式”对应图上两种货币之间的两条边，也就是说“兑换方式”M的个数是“兑换点”的两倍。

唯一值得注意的是权值，当拥有货币A的数量为V时，A到A的权值为V，即没有兑换，而A到B的权值为(V-Cab)*Rab，表示A到B手里变成了(V-Cab)*Rab元。尽管是B货币的(V-Cab)*Rab元，我们不必在意A和B货币的不同，只要找到一条路让A->?->?->.....->A是增多的就可以。注意要成环，即便环是这样的A->B->C->B->C->B->C>A。不能只关注于A->B->C->F增大，例如英镑->美元->人民币->日元。所以这是一道找正环的题目。

我们拓展一下思路：如果是没有存在正环，那我们松弛完之后，得到的是什么呢？是A货币到B货币的最大值，也就是说怎么兑换可以得到最大的B货币。

代码

#include<iostream>
#include<string.h>
using namespace std;

const int MAXN=105;//最多的货币种数
const int MAXM=210;//最多的兑换点数
int n;     //货币种数
int m;     //兑换点数量
int s;     //持有第s种货币
double v;  //持有的s货币的本金
 
int all;  //边总数
double dis[MAXN];  //s到各点的权值
 
struct exchange_points
{
    int a;      //货币a
    int b;      //货币b
    double r;   //rate
    double c;   //手续费
}exc[MAXM];
 
bool bellman(void)
{
	memset(dis,0,sizeof(dis));      //这里与bellman的目的刚好相反。初始化为源点到各点距离无穷小，以后每次松弛找较大的
	dis[s]=v;                       //自己兑换自己，，即没有兑换
	/*松弛*/
 
	bool flag;
	for(int i=1;i<=n-1;i++)
	{
		flag=false;
		for(int j=0;j<all;j++)
			if(dis[exc[j].b] < (dis[exc[j].a] - exc[j].c) * exc[j].r)         //寻找最长路径
			{                                                                 //进行比较的是"某点到自身的权值"和"某点到另一点的权值"
				dis[exc[j].b] = (dis[exc[j].a] - exc[j].c) * exc[j].r;
				flag=true;
			}
		if(!flag)
			break;
	}
 
	/*找正环*/
 
	for(int k=0;k<all;k++)                                          
		if(dis[exc[k].b] < (dis[exc[k].a] - exc[k].c) * exc[k].r)           //正环能够无限松弛
			return true;
 
	return false;
}
 
int main(void)
{
	int a,b;
	double rab,cab,rba,cba;   //临时变量
 
	while(cin>>n>>m>>s>>v)
	{
		all=0;    //注意初始化
		for(int i=0;i<m;i++)
		{
			cin>>a>>b>>rab>>cab>>rba>>cba;
			exc[all].a=a;
			exc[all].b=b;
			exc[all].r=rab;
			exc[all++].c=cab;
			exc[all].a=b;
			exc[all].b=a;
			exc[all].r=rba;
			exc[all++].c=cba;
		}
 
	    /*Bellman-form Algorithm*/
 
	    if(bellman())
	    	cout<<"YES"<<endl;
	    else
	    	cout<<"NO"<<endl;
	}
	 	
	return 0;
}