19.boost A*算法

 #include <iostream>
 #include <string>
 #include <utility>
 #include <vector>
 #include <deque>
 #include <boost/graph/adjacency_list.hpp>
 //A*寻路算法
 #include <boost\graph\astar_search.hpp>
 using namespace std;
 using namespace boost;

 enum { A, B, C, D, E, N };
 string Names = "ABCDE";
 //定义别名,两个顶点直接连接的边
 using Edge = pair<int, int>;
 //创建一个图                 边     顶点    有方向   无特性            边的权重是int
 using Graph = adjacency_list<listS, vecS, directedS, no_property, property<edge_weight_t, int>>;

 //创建一个图
 Graph make_graph()
 {
     //连接的边
     vector<Edge> edges = { {A,B},
     {A,C},
     {A,D},
     {B,E},{C,E},{D,E} };
     //边对应的权重
     vector<int> weight = { ,,,,, };

     //创建一个图对象
     return Graph(edges.begin(), edges.end(), weight.begin(), N);
 }

 //创建一个结构体,用于抛出找到信息
 struct found_goal
 {

 };

 //A*要到达的目标顶点
 template<class vertex>
 class astar_my_visitor :public boost::default_astar_visitor
 {
 public:
     //初始化内置地图
     astar_my_visitor(vertex goal) :m_goal(goal)
     {

     }
     //重载examine_vertex方法
     template<class Graph>
     void examine_vertex(vertex v, Graph &g)
     {
         //如果与目标顶点一样,则说明找到
         if (v == m_goal)
         {
             //抛出抛出找到信息
             throw found_goal();
         }
     }
 private:
     //目标顶点
     vertex m_goal;
 };

 //计算权重寻找最短路径
 template<class Graph,class costtype>
 class distance_heuristic :public boost::astar_heuristic<Graph, costtype>
 {
 public:
     //类型替换
     using Vertex = typename boost::graph_traits<Graph>::vertex_descriptor;

     //初始化
     distance_heuristic(Vertex Goal, Graph &graph):Goal_(Goal),graph_(graph)
     {

     }

     //重载()运算符 获得目标点到指定点的距离
     costtype operator()(Vertex v)
     {
         return get(vertex_index, graph_, Goal_) - get(vertex_index, graph_, v);
     }

 private:
     Vertex Goal_;
     Graph &graph_;
 };

 void main()
 {
     //创建图
     Graph myg = make_graph();

     //创建简写
     using Vertex = boost::graph_traits<Graph>::vertex_descriptor;
     using Cost = int;

     Vertex start = vertex(A, myg);//开始位置
     Vertex goal = vertex(E, myg);//结束位置

      //保存走过路径(由后向前)
     vector<Vertex>parents(boost::num_vertices(myg));
     //保存长度
     vector<Cost>distance(boost::num_vertices(myg));

     try
     {
         //求从指定点到终点的路线

         boost::astar_search_tree(myg,
             start,
             distance_heuristic<Graph, Cost>(goal, myg),//传递距离

            //求出路径，以及路径对应的权重，访问器访问                                 因为重载了()运算符
             boost::predecessor_map(&parents[]).distance_map(&distance[]).visitor(astar_my_visitor<Vertex>(goal))
         );
     }
     //catch信息
     catch (found_goal fg)
     {
         //要到的位置的前一个到达的位置如果是goal(下标是当前点,值是到这个点之前的点)
         if (parents[goal] == goal)
         {
             cout << "无路可走" << endl;
         }
         deque<Vertex> route;

         //顺藤摸瓜
         for (Vertex v = goal; v != start; v = parents[v])
         {
             route.push_front(v);
         }
         for (auto i : route)
         {
             cout << Names[i] << endl;
         }
     }

     system("pause");
 }