A Boost Graph Library Example

在http://www.kehui.net/html/article/44/44064.html上
看到一篇文章，编译运行了一下，发现和预想的结果不一致，所以，仔细研究了一下，对其做了调整。
这个例子能让我们领略BGL的强大。

//整理 by  RobinKin from DevonIT.inc
#include <boost/config.hpp>
#include <iostream>
#include <vector>
#include <string>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/depth_first_search.hpp>
#include <boost/graph/breadth_first_search.hpp>
#include <boost/property_map.hpp>
#include <boost/graph/graph_utility.hpp> // for boost::make_list

/*
  Example of using a visitor with the depth first search
    and breadth first search algorithm

  Sacramento ---- Reno ---- Salt Lake City
     |
  San Francisco
     |
  San Jose ---- Fresno
     |
  Los Angeles ---- Los Vegas ---- Pheonix
     |
  San Diego


  The visitor has three main functions:

  discover_vertex(u,g) is invoked when the algorithm first arrives at the
    vertex u. This will happen in the depth first or breadth first
    order depending on which algorithm you use.

  examine_edge(e,g) is invoked when the algorithm first checks an edge to see
    whether it has already been there. Whether using BFS or DFS, all
    the edges of vertex u are examined immediately after the call to
    visit(u).

  fiu have already been visited.hen after all the vertices reachable from vertex

*/

using namespace std;
using namespace boost;

//到达结点时 operator()
struct city_arrival : public base_visitor<city_arrival>
{
    city_arrival(string* n) : names(n)
    { }
    typedef on_discover_vertex event_filter;
    template <class Vertex, class Graph>
    inline void operator()(Vertex u, Graph&)
    {
        cout << endl << "arriving at : " << names[u] << endl;
    }
    string* names;
};

//显示邻接结点时 。调用 operator()
struct neighbor_cities : public base_visitor<neighbor_cities>
{
    neighbor_cities(string* n) : names(n)
    { }
    typedef on_examine_edge event_filter;
    template <class Edge, class Graph>
    inline void operator()(Edge e, Graph& g)
    {
        cout << "  neighboring cities are: ";
        cout << names[ target(e, g) ] << ", ";
    }
    string* names;
};

//某结点的所有邻接结点都已经被访问过时  调用 operator()
struct finish_city : public base_visitor<finish_city>
{
    finish_city(string* n) : names(n)
    { }
    typedef on_finish_vertex event_filter;
    template <class Vertex, class Graph>
    inline void operator()(Vertex u, Graph&)
    {
        cout << endl << "finished with " << names[u] << endl;
    }
    string* names;
};

int main(int, char*[])
{
    enum { SanJose, SanFran, LA, SanDiego, Fresno,
           LosVegas, Reno, Sacramento, SaltLake, Pheonix, N };

    string names[] = { "San Jose", "San Francisco",  "Los Angeles", "San Diego", "Fresno",
                       "Los Vegas", "Reno", "Sacramento", "Salt Lake City", "Pheonix"};

    typedef std::pair<int,int> E;
    E edge_array[] = { E(Sacramento, Reno), E(Sacramento, SanFran),
                       E(Reno, SaltLake),
                       E(SanFran, SanJose),
                       E(SanJose, Fresno), E(SanJose, LA),
                       E(LA, LosVegas), E(LA, SanDiego),
                       E(LosVegas, Pheonix) };

    /* Create the graph type we want. */
    //这里用邻接表来表示一个图
    typedef adjacency_list<vecS, vecS, undirectedS> Graph;

#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    //VC++ 不能处理迭代器的构造函数
    Graph G(N);
    for (std::size_t j = 0; j <  sizeof(edge_array)/sizeof(E); ++j)
    {
        add_edge(edge_array[j].first, edge_array[j].second, G);
    }
#else
    //参数分别为边起始迭代器、中止迭代器、顶点个数
    Graph G(edge_array, edge_array + sizeof(edge_array)/sizeof(E), N);
#endif

    cout << "*** Depth First ***" << endl;

    //第 1 2 3 个参数分别是 arrival neighbor  finish
    //深度遍历图，当某一事件发生时，执行预定义的操作
    depth_first_search
    (G,
     visitor(make_dfs_visitor(boost::make_list(city_arrival(names),
                              neighbor_cities(names),
                              finish_city(names)))));
    cout << endl;

    //定义源节点
    boost::graph_traits<Graph>::vertex_descriptor
    s = vertex(SanJose,G);

    cout << "*** Breadth First ***" << endl;
   
    //广度遍历图，当某一事件发生时，执行预定义的操作
    breadth_first_search
    (G, s, visitor(make_bfs_visitor(boost::make_list(city_arrival(names),
                                    neighbor_cities(names),
                                    finish_city(names)))));

    return 0;
}