单源最短路径 Bellman_ford 和 dijkstra
首先两个算法都是常用于 求单源最短路径
关键部分就在于松弛操作 实际上就是dp的感觉
if (dist[e.to] > dist[v] + e.cost)
{
dist[e.to] = dist[v] + e.cost;
...
}
bellman_ford O(E*V) 但是配合队列可以 有spfa 可以达到O(kE)
http://www.360doc.com/content/13/1208/22/14357424_335569176.shtml
并且bellman_ford还适用于负边 并且可以利用最多循环V-1次的性质 判断是否存在负圈(如果循环超过V-1次 说明有负圈 因为没重复走着负圈一次 都伴随着更新)
并且因为松弛操作是针对于每条边的遍历也可以用向前星存
1 #include <iostream> 2 #include <stdio.h> 3 #include <fstream> 4 #include <string.h> 5 #define MAXV 10007 6 #define MAXE 1007 7 #define INF 0x3f3f3f3f 8 using namespace std; 9 10 int V, E; 11 12 struct Edge 13 { 14 int from, to, cost; 15 }edge[MAXE]; 16 17 18 19 20 int bellman_ford(int s, int d)//求单源最短路径 21 { 22 int dist[MAXV]; 23 fill (dist, dist+V+10, INF); 24 dist[s] = 0; 25 while (true)//直至update不在更新 26 { 27 bool update = false; 28 for (int i = 0; i < E; i++) 29 { 30 if (dist[edge[i].from] != INF && dist[edge[i].to] > dist[edge[i].from] + edge[i].cost) 31 { 32 dist[edge[i].to] = dist[edge[i].from] + edge[i].cost; 33 update = true; 34 } 35 } 36 if (!update) break; 37 } 38 return dist[d]; 39 } 40 //while(true) 循环中最多循环V-1次 复杂度是O(V*E) 41 //如果存在 从s可达的负圈 那么在第V次循环时也会更新 可以用这个性质来检查负圈 42 //如果一开始把dist都初始化为0 那么可以检查出所有的负圈 43 //检查负边 是负边 返回true 44 //P.S 圈表示基本回路 45 bool isNegtive() 46 { 47 int dist[MAXV]; 48 memset(dist, 0, sizeof(dist));//单纯查负圈 49 for (int i = 0; i < V; i++) 50 { 51 for (int i = 0; i < E; i++) 52 { 53 Edge e = edge[i]; 54 if (dist[e.to] < dist[e.from] + e.cost ) 55 { 56 dist[e.to] = dist[e.from] + e.cost; 57 if (i == V-1)//如果第V次还更新 那么就有负圈 58 return true; 59 } 60 } 61 } 62 return false; 63 } 64 int main() 65 { 66 ifstream cin ("in.txt"); 67 cin >> V >> E; 68 for (int i = 0; i < E; i++) 69 { 70 cin >> edge[i].from >> edge[i].to >> edge[i].cost; 71 } 72 cout << bellman_ford(1, 7) << endl; 73 }
dijkstra 普通写法O(V^2)
但是 dijkstra的特点 --->>是针对每一个点 通过它所对应的边更新 e.to的节点
每次取出的是离原点sorce 最近的点 所以就可以使用优先队列 那么就变成O(V*logV)
并且因为“是针对每一个点 通过它所对应的边更新 e.to的节点 ” 那么也很好试用向前星
1 #include <iostream> 2 #include <string.h> 3 #include <fstream> 4 #include <stdio.h> 5 #include <queue> 6 #define MAXV 10007 7 #define MAXE 1007 8 #define INF 0x3f3f3f3f 9 using namespace std; 10 11 int V, E; 12 //迪杰特斯拉好像不是很好用向前星 13 //这个算法是针对每一个点更新 而向前星存储的是边的信息 要查找点就比较复杂 14 15 //用邻接矩阵存储 O(V^2)的算法 16 17 int cost[MAXV][MAXV]; 18 int dijkstra(int s, int d) 19 { 20 int dist[MAXV]; 21 bool use[MAXV]; 22 fill(dist, dist+MAXV, INF); 23 memset(use, false, sizeof(use)); 24 dist[s] = 0; 25 while (true) 26 { 27 int v = -1; 28 for (int i = 1; i <= V; i++)//找一个最近的 未使用过的点 29 { 30 if (!use[i] && (v == -1 || dist[i] < dist[v])) v = i; 31 } 32 if (v == -1) break; 33 use[v] = true; 34 for (int i = 1; i <= V; i++) 35 { 36 dist[i] = min(dist[i], dist[v] + cost[v][i]); 37 } 38 } 39 return dist[d]; 40 } 41 42 //使用优先队列(也就是heap优化)O(E*logV) 43 //针对边来dp 这里可以用向前星存储了 44 struct Edge 45 { 46 int to, n, next; 47 }edge[MAXE]; 48 int num = 0; 49 int head[MAXV]; 50 void Add(int from, int to, int c) 51 { 52 edge[num].n = c; 53 edge[num].to = to; 54 edge[num].next = head[from];//从头插入 55 head[from] = num++; 56 } 57 void init()//初始化 58 { 59 ifstream cin("in.txt"); 60 memset(edge, -1, sizeof(edge)); 61 memset(head, -1, sizeof(head)); 62 cin >> V >> E; 63 for (int j = 0; j < E; j++) 64 { 65 int from , to , c; 66 cin >> from >> to >> c; 67 Add(from, to, c); 68 } 69 } 70 71 typedef pair<int, int> P;//first 表示与s的距离, second表示点的编号 72 int pre[MAXV];//记录前驱节点 在每次dist[j] = dist[k] + cost[k][j]更新时记录在到j的最短路径上的前驱节点就是k 73 int fast_dijkstra(int s, int d) 74 { 75 int dist[MAXV]; 76 priority_queue<P, vector<P>, greater<P> > que;//用优先队列存储点的信息 每次弹出距离最短的点O(logV) 77 fill(dist, dist+MAXV, INF); 78 dist[s] = 0; 79 que.push(P(0, s)); 80 while (!que.empty()) 81 { 82 P p = que.top(); 83 que.pop(); 84 if (dist[p.second] < p.first) continue; 85 int t = head[p.second]; 86 while (t != -1) 87 { 88 Edge e = edge[t]; 89 if (dist[e.to] > dist[p.second] + e.n) 90 { 91 dist[e.to] = dist[p.second] + e.n; 92 pre[e.to] = p.second; 93 que.push( P(dist[e.to], e.to) ); 94 } 95 t = e.next; 96 } 97 } 98 return dist[d]; 99 } 100 101 int main() 102 { 103 /* 104 ifstream cin("in.txt"); 105 cin >> V >> E; 106 for (int i = 1; i <= V; i++) 107 for (int j = 1; j <= V; j++) 108 cost[i][j] = INF;//不存在时 cost为INF 109 for (int j = 0; j < E; j++) 110 { 111 int from , to , c; 112 cin >> from >> to >> c; 113 cost[from][to] = c; 114 } 115 int ans = dijkstra(1, 7); 116 */ 117 init(); 118 int ans = fast_dijkstra(1,7); 119 cout << ans << endl; 120 //这样路径即还原了 121 int t = pre[7]; 122 cout << 7 << " "; 123 while(t != 1) 124 { 125 cout << t << " "; 126 t = pre[t]; 127 } 128 cout << 1 <<endl; 129 }
