分支限界法—单源最短路径问题

  1 2.剪枝策略在算法扩展结点的过程中，一旦发现一个结点的下界不小于当前找到的最短路长，则算法剪去以该结点为根的子树。   在算法中，利用结点间的控制关系进行剪枝。从源顶点s出发，2条不同路径到达图G的同一顶点。由于两条路径的路长不同，因此可以将路长长的路径所对应的树中的结点为根的子树剪去。 3.算法思想解单源最短路径问题的优先队列式分支限界法用一极小堆来存储活结点表。其优先级是结点所对应的当前路长。算法从图G的源顶点s和空优先队列开始。结点s被扩展后，它的儿子结点被依次插入堆中。此后，算法从堆中取出具有最小当前路长的结点作为当前扩展结点，并依次检查与当前扩展结点相邻的所有顶点。如果从当前扩展结点i到顶点j有边可达，且从源出发，途经顶点i再到顶点j的所相应的路径的长度小于当前最优路径长度，则将该顶点作为活结点插入到活结点优先队列中。这个结点的扩展过程一直继续到活结点优先队列为空时为止。实现
  2 /* 主题：单源最短路径问题
  3 * 作者：chinazhangjie
  4 * 邮箱：chinajiezhang@gmail.com
  5 * 开发语言：C++
  6 * 开发环境：Mircosoft Virsual Studio 2008
  7 * 时间: 2010.11.01
  8 */
  9 
 10 #include <iostream>
 11 #include <vector>
 12 #include <queue>
 13 #include <limits>
 14 using namespace std;
 15 
 16 struct node_info
 17 {
 18 public:
 19     node_info (int i,int w) 
 20         : index (i), weight (w) {}
 21     node_info () 
 22         : index(0),weight(0) {}
 23     node_info (const node_info & ni) 
 24         : index (ni.index), weight (ni.weight) {}
 25 
 26     friend 
 27     bool operator < (const node_info& lth,const node_info& rth) {
 28         return lth.weight > rth.weight ; // 为了实现从小到大的顺序
 29     }
 30 
 31 public:
 32     int index; // 结点位置
 33     int weight; // 权值
 34 };
 35 
 36 struct path_info 
 37 {
 38 public:
 39     path_info ()
 40         : front_index(0), weight (numeric_limits<int>::max()) {}
 41 
 42 public:
 43     int front_index;
 44     int weight;
 45 };
 46 
 47 // single source shortest paths
 48 class ss_shortest_paths
 49 {
 50      
 51 public:
 52     ss_shortest_paths (const vector<vector<int> >& g,int end_location) 
 53         :no_edge (-1), end_node (end_location), node_count (g.size()) , graph (g) 
 54     {}
 55 
 56     // 打印最短路径
 57     void print_spaths () const {
 58         cout << "min weight : " << shortest_path << endl;
 59         cout << "path: " ;
 60         copy (s_path_index.rbegin(),s_path_index.rend(),
 61             ostream_iterator<int> (cout, " "));
 62         cout << endl;
 63     }
 64 
 65     // 求最短路径
 66     void shortest_paths () {
 67         vector<path_info> path(node_count);
 68         priority_queue<node_info,vector<node_info> > min_heap;
 69         min_heap.push (node_info(0,0));    // 将起始结点入队
 70 
 71         while (true) {
 72             node_info top = min_heap.top ();    // 取出最大值
 73             min_heap.pop ();
 74 
 75             // 已到达目的结点
 76             if (top.index == end_node) {
 77                 break ;
 78             }
 79             // 未到达则遍历
 80             for (int i = 0; i < node_count; ++ i) {
 81                 // 顶点top.index和i间有边，且此路径长小于原先从原点到i的路径长 
 82                 if (graph[top.index][i] != no_edge && 
 83                     (top.weight + graph[top.index][i]) < path[i].weight) {
 84                     min_heap.push (node_info (i,top.weight + graph[top.index][i]));
 85                     path[i].front_index = top.index;
 86                     path[i].weight = top.weight + graph[top.index][i];
 87                 }
 88             }
 89             if (min_heap.empty()) {
 90                 break ;
 91             }
 92         }
 93 
 94         shortest_path = path[end_node].weight;
 95         int index = end_node;
 96         s_path_index.push_back(index) ;
 97         while (true) {
 98             index = path[index].front_index ;
 99             s_path_index.push_back(index);
100             if (index == 0) {
101                 break;
102             }
103         }
104     }
105 
106 private:
107     vector<vector<int> >    graph ;            // 图的数组表示
108     int                        node_count;        // 结点个数
109     const int                no_edge;        // 无通路
110     const int                end_node;        // 目的结点
111     vector<int>                s_path_index;    // 最短路径
112     int                        shortest_path;    // 最短路径
113 };
114 
115 int main()
116 {
117     const int size = 11; 
118     vector<vector<int> > graph (size);
119     for (int i = 0;i < size; ++ i) {
120         graph[i].resize (size);
121     }
122     for (int i = 0;i < size; ++ i) {
123         for (int j = 0;j < size; ++ j) {
124             graph[i][j] = -1;
125         }
126     }
127     graph[0][1] = 2;
128     graph[0][2] = 3;
129     graph[0][3] = 4;
130     graph[1][2] = 3;
131     graph[1][5] = 2;
132     graph[1][4] = 7;
133     graph[2][5] = 9;
134     graph[2][6] = 2;
135     graph[3][6] = 2;
136     graph[4][7] = 3;
137     graph[4][8] = 3;
138     graph[5][6] = 1;
139     graph[5][8] = 3;
140     graph[6][9] = 1;
141     graph[6][8] = 5;
142     graph[7][10] = 3;
143     graph[8][10] = 2;
144     graph[9][8] = 2;
145     graph[9][10] = 2;
146 
147     ss_shortest_paths ssp (graph, 10);
148     ssp.shortest_paths ();
149     ssp.print_spaths ();
150     return 0;
151 }