Bellman-Ford算法:通过对边进行松弛操作来渐近地降低从源结点s到每个结点v的最短路径的估计值v.d,直到该估计值与实际的最短路径权重相同时为止。该算法主要是基于下面的定理:
设G=(V,E)是一带权重的源结点为s的有向图,其权重函数为W,假设图G中不包含从源结点s可到达的权重为负值的环路,在对图中的每条边执行|V|-1次松弛之后,对于所有从源结点s可到达的结点v,都有。
证明:s可到达结点v并且图中没有权重为负值的环路,所以总能找到一条路径p=(v0,v1,...,vk)是从s到v结点的最短路径,这里v0=s,vk=v。因为最短路径都是简单路径,p最多包含|V|-1条边,即k<=|V|-1。由于v0=s,所以,当对所有的边进行第1次松弛后,必有,依次类推,进行第k次松弛后,必有,最后可得进行|V|-1次松弛后有
下面证明为什么当,对边松弛后,有:。
由于s->...->vi-1->vi是一条最短路径,在对边松弛后,
有:(这个是松弛的定义)。
又由于,所以:。
Bellman-Ford算法的实现是对图中的每条边进行|V|-1次松弛。
Dijkstra算法:将图中的结点分为两类,一类是结点集合S,从源结点s到集合中每个结点之间的最短路径已经被找到。另一类集合是V-S。算法重复地从集合V-S中选择最短路径估计最小的结点u,然后将u加入到集合S,然后对所有从u出发的边进行松弛。在进行|V|次重复操作后,其中每条边经历过一次松弛,对于所有的结点v,都有。关键点是证明:该算法在每次选择结点u来加入到集合S时,有。证明过程省略,可以参考《算法导论》的证明过程。
下面给两种算法的出程序:在Dijkstra算法中,通过结点的颜色color来区分结点是属于S集合还是V-S集合,黑色时是S集合中,白色时是V-S集合中
Minpath.h
#pragma once #include<iostream> #include<string> #include<vector> using namespace std; template<typename Comparable> struct Edge; template<typename Comparable> struct Node { Comparable element;//结点的元素 vector<Edge<Comparable>*>Side;//该结点所在的边 Node<Comparable>* T; //最短路径中该结点的父亲 int dis; //距离 string color; //在Dijkstra算法中用于标记该结点是否被选中 Node(Comparable e,Node<Comparable>* f,int d,string c) { element=e; T=f; dis=d; color=c; } }; template<typename Comparable> struct Edge { Node<Comparable>* N1; //边的两端结点,N1是N2结点的父结点 Node<Comparable>* N2; string color; int weight; Edge(Node<Comparable>* n1,Node<Comparable>* n2,int w):N1(n1),N2(n2),weight(w){} }; template<typename Comparable> class graph { public: void insert(Comparable *a,int *matrix,int *w,int n);//a:图中个结点的元素;matrix:邻接矩阵 void Bellman(Comparable x); void Dijkstra(Comparable x); void MinPath(Comparable x); private: vector<Node<Comparable>*> root; vector<Edge<Comparable>*> side; Node<Comparable>* find(Comparable x); Node<Comparable>* find(); void relax(Edge<Comparable>* edge); //松弛 void MinPath(Node<Comparable>* s); };
Minpath.cpp
#include "stdafx.h" #include"Minpath.h" #include<iostream> #include<string> #include<vector> using namespace std; template<typename Comparable> void graph<Comparable>::insert(Comparable *a,int *matrix,int *w,int n) { for(int i=0;i<n;i++) { Node<Comparable>* node=new Node<Comparable>(a[i],NULL,10000,"WHITE"); root.push_back(node); } Node<Comparable>* node=NULL; Node<Comparable>* temp=NULL; int k=0; for(int i=0;i<n;i++) { node=root[i]; for(int j=0;j<n;j++) { if(matrix[n*i+j]!=0) { temp=root[j]; Edge<Comparable>* edge=new Edge<Comparable>(node,temp,w[k]); k=k+1; side.push_back(edge); node->Side.push_back(edge); } } } } //找出元素是x的结点 template<typename Comparable> Node<Comparable>* graph<Comparable>::find(Comparable x) { int n=root.size(); Node<Comparable>* temp=NULL; for(int i=0;i<n;i++) { if(root[i]->element==x) temp=root[i]; } return temp; } //边的松弛 template<typename Comparable> void graph<Comparable>::relax(Edge<Comparable>* edge) { if(edge->N2->dis>edge->N1->dis+edge->weight) { edge->N2->dis=edge->N1->dis+edge->weight; edge->N2->T=edge->N1; } } //Bellman-Ford算法:对图中的边进行|v|-1次的松弛 template<typename Comparable> void graph<Comparable>::Bellman(Comparable x) { Node<Comparable>* s=find(x); bool flag=true; if(s==NULL) return; int n=root.size(); int en=side.size(); Edge<Comparable>* edge=NULL; s->dis=0; //选择s为源结点,并初始化其距离为0 //对图中的每个边进行|V|-1次的松弛 for(int i=0;i<n-1;i++) { for(int j=0;j<en;j++) { edge=side[j]; relax(edge); //松弛 } } for(int i=0;i<en;i++) { edge=side[i]; if(edge->N2->dis>edge->N1->dis+edge->weight) flag=false; } if(flag==false) cout<<"图中包含权重为负值的环路"<<endl; else { s->T=NULL; } } //Dijkstra算法 template<typename Comparable> void graph<Comparable>::Dijkstra(Comparable x) { Node<Comparable>* s=find(x); Node<Comparable>* source=s; if(s==NULL) return; Edge<Comparable>* edge=NULL; Node<Comparable>* temp=new Node<Comparable>(s->element,NULL,10000,"WHITE"); Node<Comparable>* t=temp; int n=root.size(); s->dis=0; s->color="BLACK"; //初始化源结点 for(int i=0;i<n;i++) { int en=s->Side.size(); for(int j=0;j<en;j++) //对s结点的所有的边进行一次松弛 { edge=s->Side[j]; relax(edge); } s=find(); s->color="BLACK"; } source->T=NULL; } template<typename Comparable> Node<Comparable>* graph<Comparable>::find() { Node<Comparable>* s=new Node<Comparable>(root[0]->element,NULL,10000,"WHITE"); int n=root.size(); for(int i=0;i<n;i++) { if((root[i]->color=="WHITE")&&(root[i]->dis<s->dis)) s=root[i]; } return s; } //找出某结点的最短路径并输出 template<typename Comparable> void graph<Comparable>::MinPath(Comparable x) { Node<Comparable>* s=find(x); cout<<"最短路径为:"<<endl; MinPath(s->T); cout<<"("<<s->element<<","<<s->dis<<")"<<endl; } template<typename Comparable> void graph<Comparable>::MinPath(Node<Comparable>* s) { if(s!=NULL) { MinPath(s->T); cout<<"("<<s->element<<","<<s->dis<<")"<<"—>"; } else return; }
Algorithm-graph3.cpp
// Algorithm-graph3.cpp : 定义控制台应用程序的入口点。 //主要是图中的最短路径问题:Bellman-Ford算法和Dijkstra算法 #include "stdafx.h" #include"Minpath.h" #include"Minpath.cpp" #include<iostream> #include<string> #include<vector> using namespace std; #include<iostream> int _tmain(int argc, _TCHAR* argv[]) { graph<string> g; ////Bellman-Ford算法 /* int n=5; int matrix[25]={0,1,0,0,1, 0,0,1,1,1, 0,1,0,0,0, 1,0,1,0,0, 0,0,1,1,0}; string a[5]={"s","t","x","z","y"}; int w[10]={6,7,5,-4,8,-2,2,7,-3,9};*/ //Dijkstra算法 int n=5; int matrix[25]={0,1,0,0,1, 0,0,1,0,1, 0,0,0,1,0, 1,0,1,0,0, 0,1,1,1,0}; string a[5]={"s","t","x","z","y"}; int w[10]={10,5,1,2,4,7,6,3,9,2}; g.insert(a,matrix,w,n); // g.Bellman("s"); g.Dijkstra("s"); //选择结点元素为s的作为源结点 g.MinPath("x"); //输出结点元素是x的最短路径 return 0; }