某种带权有向无环图(graph)的所有路径的求法

// 讨论QQ群：135202158

最近做某个东西，最后用图实现了，这里总结一下算法。

假设有以下带权有向无环图（连通或非连通，我这里用的是非连通的）：

每个节点(node)可能与其他节点有向地相连，相邻节点的边（edge)有权值(weight)属性。从一个节点到任意一个节点的连的集合称为路径(path)，且路径的权为各边权的最小值。

现在的问题就是求所有可能的路径，并算出各路径的权。

以下是简单的C++代码实现，我是用遍历边来实现的，节点和边是两个数据结构：

 #include <iostream>
 #include <vector>
 #include <list>

 using namespace std;

 // 节点
 struct node
 {
     char val; 

     node(char c) : val(c) {}
 };

 // 边
 struct edge
 {
     // a->b，w为权
     node   a;
     node   b;
     int    w;

     edge(node& _a, node& _b, int _w) : a(_a), b(_b), w(_w) {}
 };

 // 遍历各边时所有的记录
 struct record
 {
     list<node>  path;   // 路径上的节点列表
     list<int>   ws;     // 当前的最小权列表
 };

 // 生成上图所示带权有向无环图
 void gen_samples(vector<node>& nodes, vector<edge>& edges);

 // 递归遍历
 void travel_path(vector<edge>& edges, edge& x, record& r)
 {
     size_t i;
     for(i=; i<edges.size(); ++i)
     {
         edge e = edges[i];
         // 判断是否连通
         if(x.b.val == edges[i].a.val)
         {
             r.path.push_back(edges[i].b);
             int w = min(x.w, edges[i].w);
             r.ws.push_back(w);
             travel_path(edges, edges[i], r);
         }
     }

     // 不与任何节点有向连通，输出路径，并回溯至上个节点
     if(i == edges.size())
     {
         for(list<node>::iterator it = r.path.begin();
             it != r.path.end(); ++it)
             cout << it->val << " ";
         cout << ", " << r.ws.back() << endl;

         r.path.pop_back();
         r.ws.pop_back();
     }
 }

 int main()
 {
     vector<node> nodes;
     vector<edge> edges;

     gen_samples(nodes, edges);

     for(size_t i=; i<edges.size(); ++i)
     {
         record r;
         r.path.push_back(edges[i].a);
         r.path.push_back(edges[i].b);
         r.ws.push_back(edges[i].w);

         travel_path(edges, edges[i], r);
     }

     system("PAUSE");
     return ;
 }

 void gen_samples(vector<node>& nodes, vector<edge>& edges)
 {
     node a('A');    nodes.push_back(a);
     node b('B');    nodes.push_back(b);
     node c('C');    nodes.push_back(c);
     node d('D');    nodes.push_back(d);
     node e('E');    nodes.push_back(e);
     node f('F');    nodes.push_back(f);
     node g('G');    nodes.push_back(g);
     node h('H');    nodes.push_back(h);
     node i('I');    nodes.push_back(i);
     node j('J');    nodes.push_back(j);
     node k('K');    nodes.push_back(k);

     edge e1(a, c, );     edges.push_back(e1);
     edge e2(b, d, );     edges.push_back(e2);
     edge e3(b, e, );     edges.push_back(e3);
     edge e4(c, f, );     edges.push_back(e4);
     edge e5(c, h, );     edges.push_back(e5);
     edge e6(e, h, );     edges.push_back(e6);
     edge e7(g, i, );     edges.push_back(e7);
     edge e8(g, j, );     edges.push_back(e8);
     edge e9(h, k, );     edges.push_back(e9);
 }

执行结果为（逗号前面是沿路径的各节点，后面的数字是路径的权）：

A C F , 4
A C H K , 1
A C H , 1
A C , 5
B D , 2
B E H K , 3
B E H , 5
B E , 7
C F , 4
C H K , 1
C H , 1
E H K , 3
E H , 5
G I , 2
G J , 8
H K , 3

出来的结果是所有可能的路径，如果要找包含某节点的最长路径的话，这个是有冗余的，需要去一下。