带权图分为有向和无向,无向图的最短路径又叫做最小生成树,有prime算法和kruskal算法;有向图的最短路径算法有dijkstra算法和floyd算法。
生成树的概念:联通图G的一个子图如果是一棵包含G的所有顶点的树,则该子图称为G的生成树生成树是联通图的极小连通子图。所谓极小是指:若在树中任意增加一条边,则将出现一个回路;若去掉一条边,将会使之编程非连通图。生成树各边的权值总和称为生成素的权。权最小的生成树称为最小生成树,常用的算法有prime算法和kruskal算法。
最短路径问题旨在寻找图中两节点之间的最短路径,常用的算法有:floyd算法和dijkstra算法。
构造最小生成树一般使用贪心策略,有prime算法和kruskal算法
prime算法
1.清空生成树,任取一个顶点加入生成树
2.在那些一个端点在生成树里,另一个端点不在生成树里的边中,选取一条权最小的边,将它和另一个端点加进生成树
3.重复步骤2,直到所有的顶点都进入了生成树为止,此时的生成树就是最小生成树
prime算法代码:
1. int prime(int cur)
2. {
3. int index;
4. int sum = 0;
5. memset(visit, false, sizeof(visit));
6. visit[cur] = true;
7. for(int i = 0; i < m; i ++){
8. dist[i] = graph[cur][i];
9. }
10.
11. for(int i = 1; i < m; i ++){
12.
13. int mincost = INF;
14. for(int j = 0; j < m; j ++){
15. if(!visit[j] && dist[j] < mincost){
16. mincost = dist[j];
17. index = j;
18. }
19. }
20.
21. visit[index] = true;
22. sum += mincost;
23.
24. for(int j = 0; j < m; j ++){
25. if(!visit[j] && dist[j] > graph[index][j]){
26. dist[j] = graph[index][j];
27. }
28. }
29. }
30. return sum;
31}
kruskal算法
构造一个只含n个顶点,而边集为空的子图,若将该子图中各个顶点看成是各棵树的根节点,则它是一个含有n棵树的森林。之后,从网的边集中选取一条权值最小的边,若该边的两个顶点分属不同的树,则将其加入子图,也就是这两个顶点分别所在的两棵树合成一棵树;反之,若该边的两个顶点已落在同一棵树上,则不可取,而应该取下一条权值最小的边再试之。依次类推,直至森林只有一棵树。kruskal算法能够在并查集的基础很快的实现。结合例子来介绍具体算法实现(其中并查集的部分可以详见并查集介绍部分)
1. #include<iostream>
2. #include<algorithm>
3. using namespace std;
4.
5. const int size = 128;
6. int n;
7. int father[size];
8. int rank[size];
9.
10.//把每条边成为一个结构体,包括起点、终点和权值
11. typedef struct node
12.{
13. int val;
14. int start;
15. int end;
16.}edge[SIZE * SIZE / 2];
17.
18.//把每个元素初始化为一个集合
19. void make_set()
20.{
21. for(int i = 0; i < n; i ++){
22. father[i] = i;
23. rank[i] = 1;
24. }
25. return ;
26.}
27.
28.//查找一个元素所在的集合,即找到祖先
29. int find_set(int x)
30.{
31. if(x != father[x]){
32. father[x] = find_set(father[x]);
33. }
34. return father[x];
35. }
36.
37. //合并x,y所在的两个集合:利用Find_Set找到其中两个
38.//集合的祖先,将一个集合的祖先指向另一个集合的祖先。
39. void Union(int x, int y)
40.{
41. x = find_set(x);
42. y = find_set(y);
43. if(x == y){
44. return ;
45. }
46. if(rank[x] < rank[y]){
47. father[x] = find_set(y);
48. }
49. else{
50. if(rank[x] == rank[y]){
51. rank[x] ++;
52. }
53. father[y] = find_set(x);
54. }
55. return ;
56.}
57.
58.bool cmp(pnode a, pnode b)
59. {
60. return a.val < b.val;
61. }
62.
63. int kruskal(int n) //n为边的数量
64.{
65. int sum = 0;
66. make_set();
67. for(int i = 0; i < n; i ++){ //从权最小的边开始加进图中
68. if(find_set(edge[i].start) != find_set(edge[i].end)){
69. Union(edge[i].start, edge[i].end);
70. sum += edge[i].val;
71. }
72. }
73. return sum;
74.}
75.
76.int main()
77. {
78. while(1){
79. scanf("%d", &n);
80. if(n == 0){
81. break;
82. }
83. char x, y;
84. int m, weight;
85. int cnt = 0;
86. for(int i = 0; i < n - 1; i ++){
87. cin >> x >> m;
88. //scanf("%c %d", &x, &m);
89. //printf("%c %d ", x, m);
90. for(int j = 0; j < m; j ++){
91. cin >> y >> weight;
92. //scanf("%c %d", &y, &weight);
93. //printf("%c %d ", y, weight);
94. edge[cnt].start = x - 'A';
95. edge[cnt].end = y - 'A';
96. edge[cnt].val = weight;
97. cnt ++;
98. }
99. }
100.
101. sort(edge, edge + cnt, cmp); //对边按权从小到大排序
102. cout << kruskal(cnt) << endl;
103. }
104.}
最短路径问题
最短路径问题旨在寻找图中两节点之间的最短路径,常用的算法有:floyd算法和dijkstra算法。
floyd算法
最简单的最短路径算法,可以计算图中任意两点间的最短路径 folyd算法的时间复杂度是O(N3),如果是一个没有边权的图,把相连的两点 间的距离设为dist[i][j] = 1,不相连的两点设为无穷大,用 floyd算法可以判断i,j两点是否有路径相连。
核心代码:
[cpp] view plain copy
1. void floyd()
2. {
3. for(int k = 0; k < n; k ++){ //作为循环中间点的k必须放在最外一层循环
4. for(int i = 0; i < n; i ++){
5. for(int j = 0; j < n; j ++){
6. if(dist[i][j] > dist[i][k] + dist[k][j]){
7. dist[i][j] = dist[i][k] + dist[k][j]; //dist[i][j]得出的是i到j的最短路径
8. }
9. }
10. }
11. }
12.}
dijkstra算法
用来计算从一个点到其他所有点的最短路径的算法,复杂度O(N2)。
核心代码:
[cpp] view plain copy
1. void dijkstra(int s) //s是起点
2. {
3. memset(visit, false, sizeof(visit));
4. visit[s] = true;
5. for(int i = 0; i < n; i ++){
6. dist[i] = graph[s][i];
7. }
8.
9. int index;
10. for(int i = 1; i < n; i ++){
11. int mincost = INF;
12. for(int j = 0; j < n; j ++){
13. if(!visit[j] && dist[j] < mincost){
14. mincost = dist[j];
15. index = j;
16. }
17. }
18. visit[index] = true;
19. for(int j = 0; j < n; j ++){
20. if(!visit[j] && dist[j] > dist[index] + graph[index][j]){
21. dist[j] = dist[index] + graph[index][j];
22. }
23. }
24. }
25. }