最小生成树&&最短路径

带权图分为有向和无向，无向图的最短路径又叫做最小生成树，有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 <
f940
span>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. }