《Boost》Part1 Minimum Spanning Tree
1、Boost中的最小生成树介绍
MST最小生成树,是图论中的基本算法,还有一种是最大生成树,此处暂不介绍。
最小生成树其实是最小权重生成树的简称。最小生成树包括两种常见的MST:Prim算法和Kruskal算法。第一个用于寻找最小生成树的算法由捷克科学家奥塔卡尔·布卢瓦卡提出,即Borůvka算法。
Boost库也提供了这两个算法的函数,直接调用即可。
该算法改进后用在超体素分割算法中,效果很好。既然作为图论中的算法,从名字就可以看出,用它来规划路径很好,也就是说,由于点云相对比较密集,可以生成最短直线或者曲线。
2、图论中的带权图分类
带权图分为有向和无向,无向图的最短路径又叫做最小生成树,有prime算法和kruskal算法;有向图的最短路径算法有dijkstra算法和floyd算法。
生成树的概念:连通图G的一个子图如果是一棵包含G的所有顶点的树,则该子图称为G的生成树。 生成树是连通图的极小连通子图。所谓极小是指:若在树中任意增加一条边,则 将出现一个回路;若去掉一条边,将会使之变成非连通图。生成树各边的权 值总和称为生成树的权。权最小的生成树称为最小生成树,常用的算法有prime算法和kruskal算法。
最短路径问题旨在寻找图中两节点之间的最短路径,常用的算法有:floyd算法和dijkstra算法。
3、无向图——prime算法
构造最小生成树一般使用贪心策略,有prime算法和kruskal算法
1)、prime算法思路:
(1)清空生成树,任取一个顶点加入生成树
(2)在那些一个端点在生成树里,另一个端点不在生成树里的边中,选取一条权最小的边,将它和另一个端点加进生成树
(3)重复步骤(2),直到所有的顶点都进入了生成树为止,此时的生成树就是最小生成树
2)、prime算法实现函数
int prime(int cur)
{
int index;
int sum = 0;
memset(visit, false, sizeof(visit));
visit[cur] = true;
for(int i = 0; i < m; i ++){
dist[i] = graph[cur][i];
}
for(int i = 1; i < m; i ++){
int mincost = INF;
for(int j = 0; j < m; j ++){
if(!visit[j] && dist[j] < mincost){
mincost = dist[j];
index = j;
}
}
visit[index] = true;
sum += mincost;
for(int j = 0; j < m; j ++){
if(!visit[j] && dist[j] > graph[index][j]){
dist[j] = graph[index][j];
}
}
}
return sum;
}
3)、再给出Boost中的Prim算法例子:
//#include <boost/config.hpp>
#include <iostream>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/prim_minimum_spanning_tree.hpp>
int
main()
{
using namespace boost;
typedef adjacency_list < vecS, vecS, undirectedS,
property<vertex_distance_t, int>, property < edge_weight_t, int > > Graph;
typedef std::pair < int, int >E;
const int num_nodes = 5;
E edges[] = { E(0, 2), E(1, 3), E(1, 4), E(2, 1), E(2, 3),
E(3, 4), E(4, 0)
};
int weights[] = { 1, 1, 2, 7, 3, 1, 1 };
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
Graph g(num_nodes);
property_map<Graph, edge_weight_t>::type weightmap = get(edge_weight, g);
for (std::size_t j = 0; j < sizeof(edges) / sizeof(E); ++j) {
graph_traits<Graph>::edge_descriptor e; bool inserted;
tie(e, inserted) = add_edge(edges[j].first, edges[j].second, g);
weightmap[e] = weights[j];
}
#else
Graph g(edges, edges + sizeof(edges) / sizeof(E), weights, num_nodes);
property_map<Graph, edge_weight_t>::type weightmap = get(edge_weight, g);
#endif
std::vector < graph_traits < Graph >::vertex_descriptor >
p(num_vertices(g));
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
property_map<Graph, vertex_distance_t>::type distance = get(vertex_distance, g);
property_map<Graph, vertex_index_t>::type indexmap = get(vertex_index, g);
prim_minimum_spanning_tree
(g, *vertices(g).first, &p[0], distance, weightmap, indexmap,
default_dijkstra_visitor());
#else
prim_minimum_spanning_tree(g, &p[0]);
#endif
for (std::size_t i = 0; i != p.size(); ++i)
if (p[i] != i)
std::cout << "parent[" << i << "] = " << p[i] << std::endl;
else
std::cout << "parent[" << i << "] = no parent" << std::endl;
return EXIT_SUCCESS;
}
4、无向图—— kruskal算法
(1)构造一个只含n个顶点,而边集为空的子图,若将该子图中各个顶点看成是各棵树的根节点,则它是一个含有n棵树的森林 。
(2)之后,从网的边集中选取一条权值最小的边,若该边的两个顶点分属不同的树 ,则将其加入子图,也就是这两个顶点分别所在的 两棵树合成一棵树;反之,若该边的两个顶点已落在同一棵树上,则不可取,而应该取下一条权值最小的边再试之。
(3)依次类推,直至森林只有一棵树。
kruskal算法能够在并查集的基础很快的实现。结合例子来介绍具体算法实现:北京大学ACM——SMT
该题的代码:
#include<iostream>
#include<algorithm>
using namespace std;
const int size = 128;
int n;
int father[size];
int rank[size];
//把每条边成为一个结构体,包括起点、终点和权值
typedef struct node
{
int val;
int start;
int end;
}edge[SIZE * SIZE / 2];
//把每个元素初始化为一个集合
void make_set()
{
for(int i = 0; i < n; i ++){
father[i] = i;
rank[i] = 1;
}
return ;
}
//查找一个元素所在的集合,即找到祖先
int find_set(int x)
{
if(x != father[x]){
father[x] = find_set(father[x]);
}
return father[x];
}
//合并x,y所在的两个集合:利用Find_Set找到其中两个
//集合的祖先,将一个集合的祖先指向另一个集合的祖先。
void Union(int x, int y)
{
x = find_set(x);
y = find_set(y);
if(x == y){
return ;
}
if(rank[x] < rank[y]){
father[x] = find_set(y);
}
else{
if(rank[x] == rank[y]){
rank[x] ++;
}
father[y] = find_set(x);
}
return ;
}
bool cmp(pnode a, pnode b)
{
return a.val < b.val;
}
int kruskal(int n) //n为边的数量
{
int sum = 0;
make_set();
for(int i = 0; i < n; i ++){ //从权最小的边开始加进图中
if(find_set(edge[i].start) != find_set(edge[i].end)){
Union(edge[i].start, edge[i].end);
sum += edge[i].val;
}
}
return sum;
}
int main()
{
while(1){
scanf("%d", &n);
if(n == 0){
break;
}
char x, y;
int m, weight;
int cnt = 0;
for(int i = 0; i < n - 1; i ++){
cin >> x >> m;
//scanf("%c %d", &x, &m);
//printf("%c %d ", x, m);
for(int j = 0; j < m; j ++){
cin >> y >> weight;
//scanf("%c %d", &y, &weight);
//printf("%c %d ", y, weight);
edge[cnt].start = x - 'A';
edge[cnt].end = y - 'A';
edge[cnt].val = weight;
cnt ++;
}
}
sort(edge, edge + cnt, cmp); //对边按权从小到大排序
cout << kruskal(cnt) << endl;
}
}
5、有向图—— floyd算法
floyd算法是最简单的最短路径算法,可以计算图中任意两点间的最短路径 folyd算法的时间复杂度是O(N3)。如果是一个没有边权的图,把相连的两点 间的距离设为dist[i][j] = 1,不相连的两点设为无穷大,用 floyd算法可以判断i,j两点是否有路径相连。这种效率肯定有点低,处理大量的点时,需要改进
实现函数:
void floyd()
{
for(int k = 0; k < n; k ++){ //作为循环中间点的k必须放在最外一层循环
for(int i = 0; i < n; i ++){
for(int j = 0; j < n; j ++){
if(dist[i][j] > dist[i][k] + dist[k][j]){
dist[i][j] = dist[i][k] + dist[k][j]; //dist[i][j]得出的是i到j的最短路径
}
}
}
}
}
6、有向图——dijkstra算法
用来计算从一个点到其他所有点的最短路径的算法,复杂度O(N2)。
void dijkstra(int s) //s是起点
{
memset(visit, false, sizeof(visit));
visit[s] = true;
for(int i = 0; i < n; i ++){
dist[i] = graph[s][i];
}
int index;
for(int i = 1; i < n; i ++){
int mincost = INF;
for(int j = 0; j < n; j ++){
if(!visit[j] && dist[j] < mincost){
mincost = dist[j];
index = j;
}
}
visit[index] = true;
for(int j = 0; j < n; j ++){
if(!visit[j] && dist[j] > dist[index] + graph[index][j]){
dist[j] = dist[index] + graph[index][j];
}
}
}
}