单源最短路径两个重要算法

单源最短路径两个重要算法：BellmanFord 和 Dijkstra。

BellmanFord：

可以解决带负权的单源最短路径问题，能够检测回路中的负权环。也常用于查分约束系统问题的求解。

时间复杂度为 O(VE)。

Dijkstra：

用于求解非负权的单源最短路径问题。

时间复杂度：根据数据的存储有关系，采用最小优先队列可以达到复杂度的下限，（Prim最小生成树也可以用最小优先队列进行优化处理)。

另外：

有向无回路图中的单源最短路径问题：即先对原图进行拓扑排序，然后按照拓扑排序后的顺序依次执行一遍松弛操作即可，时间复杂度为 O(V+E)。

【BellmanFord主要算法思想和函数】

#include <iostream> using namespace std; const int N=50001; /* 单源最短路径:Bellman-Ford算法 算法思想: 用d[v]表示源点到每一个顶点的距离,运用松弛技术,对每个顶点v,逐步减小从源s到v的最短路径的权的估计值d[v], 直到其达到实际最短路径的权.如果图中不包含从源点可达的负权回路,则函数返回true,否则返回false. 应用范围: 解决带负权的单源最短路径问题,也常用于查分约束系统问题的求解. */ /* 矩阵存储图. n:顶点个数; cost:边以及权值 dis:存储源点到v点的距离 pre:到达点v的前驱结点 */ template <class T> bool BellmanFord(const int & n,T cost[][N],T dis[N],int * pre=NULL) { memset(dis,0x3F,sizeof(T)*n); if(pre) memset(pre,-1,sizeof(int)*n); dis[0]=0; int i,j,k; for(i=1;i<n;i++) { for(j=0;j<n;j++) { for(k=0;k<n;k++) { if(j==k) continue; if(dis[j]+cost[j][k]<dis[k]) { dis[k]=dis[j]+cost[j][k]; if(pre) pre[k]=j; } } } } for(j=0;j<n;j++) { for(k=0;k<n;k++) { if(dis[k]>dis[j]+cost[j][k]) return false; } } return true; } /* 邻接表存储图. n:顶点个数; cost:边以及权值 dis:存储源点到v点的距离 pre:到达点v的前驱结点 */ template <class T> struct Node { Node(int t=0,T c=0,Node * n=NULL):to(t),cost(c),next(n){} int to; T cost; Node * next; }; template <class T> bool BellmanFord(const int & n,Node<T> * link[N],T dis[N],int * pre=NULL) { memset(dis,0x3F,sizeof(T)*n); if(pre) memset(pre,-1,sizeof(int)*n); dis[0]=0; Node<T> * p; int i,j; for(i=1;i<n;i++) { for(j=0;j<n;j++) { p=link[j]; while(p) { if(dis[j]+p->cost<dis[p->to]) { dis[p->to]=dis[j]+p->cost; if(pre) pre[p->to]=j; } p=p->next; } } } for(j=0;j<n;j++) { p=link[j]; while(p) { if(dis[j]+p->cost<dis[p->to]) return false; p=p->next; } } return true; } template <class T> void AddNode(Node<T> * arr[],int a,int b,int c) { arr[a]=new Node<T>(b,c,arr[a]); } int main() { int dis[N],pre[N]; int a,b,c,n; Node<int> * arr[N]; memset(arr,0,sizeof(arr)); scanf("%d",&n); while(scanf("%d%d%d",&a,&b,&c)!=EOF) AddNode(arr,a,b,c); BellmanFord(n,arr,dis); for(int i=0;i<n;i++) printf("%d/n",dis[i]); return 0; }

 

【Dijkstra主要算法思想和函数】

 

#include <iostream> using namespace std; const int N=1000; /* 单源最短路径:Dijkstra算法 算法思想: 从源点开始,每次合并距离源点所在集合最近的点到源点集合,距离用dis[]记录, 合并之后应用松弛原理更新dis[]的值.直到所有的点均在源点集合,或者发现了图不连通. 应用范围: 有向图,边的权值非负. */ template <class T> struct Node { Node(int t=0,T c=0,Node * n=NULL):to(t),cost(c),next(n){} int to; T cost; Node * next; }; /* n:图中结点个数 link:图的邻接表表示 dis:存放距离的数组 pre:存放结点前驱的数组 */ template <class T> bool Dijkstra(const int & n,Node<T> * link[N],T * dis,int * pre=NULL) { memset(dis,0x3f,sizeof(T)*n); if(pre) memset(pre,-1,sizeof(int)*n); bool vst[N]={false}; dis[0]=0; int i,j; for(i=0;i<n;i++) { T Max=0x3f3f3f3f; int idx=-1; for(j=0;j<n;j++) { if(! vst[j] && dis[j]<Max) { Max=dis[j]; idx=j; } } if(idx==-1) return false; vst[idx]=true; Node<T> * p=link[idx]; while(p) { if(p->cost+dis[idx]<dis[p->to]) { dis[p->to]=p->cost+dis[idx]; if(pre) pre[p->to]=idx; } p=p->next; } } return true; } template <class T> void AddNode(Node<T> * * arr,int a,int b,T c) { arr[a]=new Node<T>(b,c,arr[a]); } int main() { int n; int a,b,c; Node<int> * link[N]; memset(link,0,sizeof(link)); scanf("%d",&n); while(scanf("%d%d%d",&a,&b,&c)!=EOF) AddNode(link,a,b,c); int dis[N],pre[N]; Dijkstra(n,link,dis,pre); for(int i=0;i<n;i++) printf("%d %d/n",dis[i],pre[i]); return 0; }

 

如果原作者认为侵权，请与我联系！