单源最短路径
1、Bellman-Ford算法
该算法能解决单源最短路径问题，即使存在负权边的情况下。运行Bellman-Ford算法可以返回一个布尔值，如果为true，则说明图中不包含从源点可达的负权回路，算法将产生最短路径及其权值；如果为false，则说明图中包含从源点可达的负权回路，该问题无解。
View Code
1 int d[50];
2 int p[50];
3
4 //initialize each distance of vertex to source, first source can't be reached
5 //p is the parent of vertex
6 void Init_SingleSource(const Graph* g,int source)
7 {
8 for(int i=0;i<g->vertex_num;++i)
9 {
10 d[i]=999;
11 p[i]=0;
12 }
13 d[source-1]=0;
14 }
15
16 //one step of relaxation
17 void Relaxation(int u,int v,int w)
18 {
19 if(d[u-1]+w<d[v-1])
20 {
21 d[v-1]=d[u-1]+w;
22 p[v-1]=u;
23 }
24 }
Bellman-Ford
1 //First we initialize d & p,then we do relaxation on every edges, all |V|-1 times
2 //Last we check whether there is negative-weight circuit in the graph
3 bool Bellman_Ford(const Graph* g)
4 {
5 Init_SingleSource(g,1);
6 for(int i=1;i<=g->vertex_num-1;++i)
7 {
8 for(int j=0;j<g->edge_num;++j)
9 {
10 int u=g->edges[j].u;
11 int v=g->edges[j].v;
12 int w=g->edges[j].weight;
13 Relaxation(u,v,w);
14 }
15 }
16
17 for(int i=0;i<g->edge_num;++i)
18 {
19 int u=g->edges[i].u;
20 int v=g->edges[i].v;
21 int w=g->edges[i].weight;
22 if(d[v-1]>d[u-1]+w)
23 return false;
24 }
25 return true;
26 }
2、有向无环图(DAG)中得单源最短路径
首先进行拓扑排序；
然后初始化d和p；
接着按照拓扑排序的顺序遍历每一个顶点，对每一个顶点的边进行松弛操作。
3、Dijkstra算法
该算法解决了有向图上带权的单源最短路径问题，但要求所有的边的权值非负。
首先自己实现最小优先队列
priority queue
1 struct DijInfo
2 {
3 int dist;
4 int vertex;
5 };
6
7 DijInfo info[50];
8
9 void Maintain_Heap(DijInfo* arr,int i,int n)
10 {
11 while(2*(i+1)<=n)
12 {
13 int left=2*(i+1)-1;
14 int right;
15 if(2*(i+1)==n)
16 right=left;
17 else
18 right=2*(i+1);
19 int largest=i;
20 if(arr[left].dist>arr[largest].dist)
21 largest=left;
22 if(arr[right].dist>arr[largest].dist)
23 largest=right;
24 if(i==largest)
25 return;
26 else
27 {
28 int tmp=arr[largest].dist;
29 arr[largest].dist=arr[i].dist;
30 arr[i].dist=tmp;
31 tmp=arr[largest].vertex;
32 arr[largest].vertex=arr[i].vertex;
33 arr[i].vertex=tmp;
34 i=largest;
35 }
36 }
37 }
38
39 void Build_Heap(DijInfo* arr,int n)
40 {
41 int m=n/2-1;
42 for(;m>=0;--m)
43 Maintain_Heap(arr,m,n);
44 }
45
46 void Sort_Heap(DijInfo* arr,int n)
47 {
48 Build_Heap(arr,n);
49 for(int i=n-1;i>0;--i)
50 {
51 int tmp=arr[0].dist;
52 arr[0].dist=arr[i].dist;
53 arr[i].dist=tmp;
54 tmp=arr[0].vertex;
55 arr[0].vertex=arr[i].vertex;
56 arr[i].vertex=tmp;
57 Maintain_Heap(arr,0,i);
58 }
59 }
Dijkstra
1 void Init_DijInfo(const Graph* g)
2 {
3 for(int i=0;i<g->vertex_num;++i)
4 {
5 info[i].vertex=i+1;
6 info[i].dist=d[i];
7 }
8 }
9
10 int search_info(int m,int n)
11 {
12 for(int i=0;i<n;++i)
13 if(info[i].vertex==m)
14 return i;
15 return n;
16 }
17
18 void Relaxation_Dij(int u,int v,int w,const Graph* g)
19 {
20 int i=search_info(u,g->vertex_num);
21 int j=search_info(v,g->vertex_num);
22 int d1=info[i].dist;
23 int d2=info[j].dist;
24 if(d1+w<d2)
25 info[j].dist=info[i].dist+w;
26 }
27
28 void Dijkstra(const Graph* g)
29 {
30 Init_SingleSource(g,1);
31 Init_DijInfo(g);
32 for(int i=0;i<g->vertex_num;++i)
33 {
34 Sort_Heap(info,g->vertex_num);
35 int u=info[i].vertex;
36 Edge* link=g->vertices[u-1].head;
37 while(link!=NULL)
38 {
39 int v=link->adj_vertex;
40 int w=link->weight;
41 Relaxation_Dij(u,v,w,g);
42 link=link->next;
43 }
44 }
45 }
再给出一下伪代码
Dijkstra
1 DIJKSTRA(G,w,s)
2 INITIALIZE-SINGLE-SOURCE(G,s)
3 S=NULL
4 Q=V(G)
5 while(!Q.empty())
6 u=EXTRACT-MIN(Q)
7 S=S U {u}
8 for each vertex v which is ajacent vertex of u
9 RELAX(u,v,w)
Dijkstra算法和广度优先搜索算法和Prim算法有相似之处。Dijkstra算法和广度优先搜索算法的相似之处在于，前者的集合S相当于后者的黑色顶点集合，正如集合S中的顶点有着最终的最短路径权值，广度优先搜索中的黑色顶点也有着正确的广度优先距离。Dijkstra算法与Prim算法的相似之处在于，两种算法均采用最小优先队列，来找出给定集合以外“最轻”的顶点，然后把该点加入到集合中，并相应调整该集合以外剩余顶点的权。
