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

单源最短路径两个重要算法：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;}

 

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