单源最短路径—Bellman-Ford和Dijkstra算法
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;
}
