Dijkstra算法
算法流程:
(a) 初始化:用起點v到該頂點w的直接邊(弧)初始化最短路徑,否則設爲∞;
(b) 從未求得最短路徑的終點中選擇路徑長度最小的終點u:即求得v到u的最短路徑;
(c) 修改最短路徑:計算u的鄰接點的最短路徑,若(v,…,u)+(u,w)<(v,…,w),則以(v,…,u,w)代替。
(d) 重複(b)-(c),直到求得v到其餘所有頂點的最短路徑。
特點:總是按照從小到大的順序求得最短路徑。
假設一共有N個節點,出發結點爲s,需要一個一維數組prev[N]來記錄前一個節點序號,一個一維數組dist[N]來記錄從原點到當前節點最短路徑(初始值爲s到Vi的邊的權值,沒有則爲+∞),一個二維數組weights[N][N]來記錄各點之間邊的權重,按以上流程更新prev[N]和dist[N]。
參考代碼:
#include <iostream>
#include <cstdlib>
using namespace std;
void Dijkstra(int n,int s,int *dist,int *prev,int w[][4])
{
int maxint = 65535;
bool *visit = new bool[n];
for (int i = 0; i < n; i++)
{
dist[i] = w[s][i];
visit[i] = false;
if (dist[i] != maxint)
{
prev[i] = s;
}
}
dist[s] = 0;
visit[s] = true;
for (int i = 0; i < n; i++)
{
int temp = maxint;
int u = s;
for (int j = 0; j < n; j++)
{
if ((!visit[j]) && (dist[j] < temp))
{
u = j;
temp = dist[j];
}
}
visit[u] = true;
for (int j = 0; j < n; j++)
{
if (!visit[j])
{
int newdist = dist[u] + w[u][j];
if (newdist < dist[j])
{
dist[j] = newdist;
prev[j] = u;
}
}
}
}
delete []visit;
}
int main()
{
int n,v,u;
int weight[4][4]={
0,2,65535,4,
2,0,3,65535,
65535,3,0,2,
4,65535,2,0
};
int q = 0;
int way[4];
int dist[4];
int prev[4];
int s = 1;
int d = 3;
Dijkstra(4, s, dist, prev, weight);
cout<<"The least distance from "<<s<<" to "<<d<<" is "<<dist[d]<<endl;
int w = d;
while (w != s)
{
way[q++] = prev[w];
w = prev[w];
}
cout<<"The path is ";
for (int j = q-1; j >= 0; j--)
{
cout<<way[j]<<" ->";
}
cout<<d<<endl;
return 0;
}
運行結果:
The least distance from l to 3 is 5.
The path is 1-> 2-> 3
Bellman-Ford算法
Bellman-Ford算法能在更普遍的情況下(存在負權邊)解決單源點最短路徑問題。對於給定的帶權(有向或無向)圖 G=(V,E),其源點爲s,加權函數 w 是邊集 E 的映射。對圖G運行Bellman-Ford算法的結果是一個布爾值,表明圖中是否存在着一個從源點s可達的負權迴路。若不存在這樣的迴路,算法將給出從源點s到圖G的任意頂點v的最短路徑d[v]。
Bellman-Ford算法流程分爲三個階段:
(1)初始化:將除源點外的所有頂點的最短距離估計值 d[v] ←+∞, d[s] ←0;
(2)迭代求解:反覆對邊集E中的每條邊進行鬆弛操作,使得頂點集V中的每個頂點v的最短距離估計值逐步逼近其最短距離;(運行|v|-1次)
(3)檢驗負權迴路:判斷邊集E中的每一條邊的兩個端點是否收斂。如果存在未收斂的頂點,則算法返回false,表明問題無解;否則算法返回true,並且從源點可達的頂點v的最短距離保存在 d[v]中。
算法描述如下:
Bellman-Ford(G,w,s) :boolean //圖G ,邊集 函數 w ,s爲源點
1 for each vertex v ∈ V(G) do //初始化 1階段
2 d[v] ←+∞
3 d[s] ←0; //1階段結束
4 for i=1 to |v|-1 do //2階段開始,雙重循環。
5 for each edge(u,v) ∈E(G) do //邊集數組要用到,窮舉每條邊。
6 If d[v]> d[u]+ w(u,v) then //鬆弛判斷
7 d[v]=d[u]+w(u,v) //鬆弛操作 2階段結束
8 for each edge(u,v) ∈E(G) do
9 If d[v]> d[u]+ w(u,v) then
10 Exit false
11 Exit true
適用條件和範圍:
1.單源最短路徑(從源點s到其它所有頂點v);
2.有向圖&無向圖(無向圖可以看作(u,v),(v,u)同屬於邊集E的有向圖);
3.邊權可正可負(如有負權迴路輸出錯誤提示);
4.差分約束系統;
#include <stdio.h>
#include <stdlib.h>
/* Let INFINITY be an integer value not likely to be
confused with a real weight, even a negative one. */
#define INFINITY ((1 << 14)-1)
typedef struct
{
int source;
int dest;
int weight;
} Edge;
void BellmanFord(Edge edges[], int edgecount, int nodecount, int source)
{
int *distance =(int*) malloc(nodecount*sizeof(int));
int i, j;
for (i=0; i < nodecount; ++i)
distance[i] = INFINITY;
distance[source] = 0;
for (i=0; i < nodecount; ++i)
{
int nbChanges = 0;
for (j=0; j < edgecount; ++j)
{
if (distance[edges[j].source] != INFINITY)
{
int new_distance = distance[edges[j].source] + edges[j].weight;
if (new_distance < distance[edges[j].dest])
{
distance[edges[j].dest] = new_distance;
nbChanges++;
}
}
}
// if one iteration had no impact, further iterations will have no impact either
if (nbChanges == 0) break;
}
for (i=0; i < edgecount; ++i)
{
if (distance[edges[i].dest] > distance[edges[i].source] + edges[i].weight)
{
puts("Negative edge weight cycles detected!");
free(distance);
return;
}
}
for (i=0; i < nodecount; ++i)
{
printf("The shortest distance between nodes %d and %d is %d\n", source, i, distance[i]);
}
free(distance);
return;
}
int main(void)
{
/* This test case should produce the distances 2, 4, 7, -2, and 0. */
Edge edges[10] = {{0,1, 5}, {0,2, 8}, {0,3, -4}, {1,0, -2},
{2,1, -3}, {2,3, 9}, {3,1, 7}, {3,4, 2},
{4,0, 6}, {4,2, 7}};
BellmanFord(edges, 10, 5, 4);
return 0;
}