我使用哪种增强图算法？

Question

我有一组节点A-G，Z，其中定义了加权边，其中A-G是漏斗中的各种节点，Z位于最底部。

可视化具有各种边缘的漏斗（V形），但最终指向最终节点Z，就像水流向单点Z.我们希望找到最便宜的路径，直到Z，覆盖所有节点漏斗。

以下是限制因素：

• 没有孤立节点（所有节点都已连接/包含）
• 我们希望最小化加权边的总和
• “共享边缘”，就像水向下流动时合并一样，只计算共享边缘的重量一次（换句话说，它可以自由地沿湿路径流动）

我应该使用哪种增强图算法来找到此问题的最佳边缘集？

• A-B-D-E-Z是一种涵盖大量节点的廉价路径
• C-G-Z有点强制，因为G只有一条路径到Z
• FZ看起来便宜，但后来我们注意到，由于CGZ被迫，FGZ实际上比FZ便宜（因为我们不需要重新计算GZ段，FG的增量成本只有1）

因此，边缘集应为（A-B，B-D，D-E，E-Z，C-G，F-G，G-Z）

我确信这不是一个新问题：我只是不知道足够的图论来识别/命名算法。

更新

在进一步研究问题时，我发现如果图表没有定向，问题就会减少到最小生成树。换句话说，如果我们没有先验地指出Z是图中的最低点（通过使用箭头），并允许水在两个方向上流动（通常是真的，除非我们有阀门），那么第二个模型可以正常工作。

当然，我们现在可以选择新的F-Z无向边来减轻重量，而不是被迫使用旧的G-Z定向边。

根据这些结果，如果我们确实需要边缘定向，liori's answer是原始问题的最佳响应（即需要对算法进行编码）。 / p>

输出

D <--> E with weight of 1
F <--> G with weight of 1
A <--> B with weight of 2
E <--> Z with weight of 2
C <--> G with weight of 2
F <--> Z with weight of 2
B <--> D with weight of 3
Total Weight = 13

使用最小生成树的无向非循环图代码

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/kruskal_min_spanning_tree.hpp>
#include <iostream>

int
main()
{
  using namespace boost;

  typedef adjacency_list < vecS, vecS, undirectedS,
    no_property, property < edge_weight_t, int > > Graph;
  typedef graph_traits < Graph >::edge_descriptor Edge;
  typedef graph_traits < Graph >::vertex_descriptor Vertex;
  typedef std::pair<int, int> E;

  char letter[] = "ABCDEFGZ";
  const int num_nodes = 8;
  E edge_array[] = { 
        E(0,1), E(1,2), E(1,3), E(3,6), E(3,5), E(3,4), E(2,5), E(2,6), 
        E(5,7), E(5,6), E(6,7), E(4,7) 
  };
  int weights[] = { 2, 6, 3, 5, 3, 1, 4, 2, 2, 1, 3, 2 };
  std::size_t num_edges = sizeof(edge_array) / sizeof(E);
  Graph g(edge_array, edge_array + num_edges, weights, num_nodes);
  property_map < Graph, edge_weight_t >::type weight = get(edge_weight, g);
  std::vector < Edge > spanning_tree;

  kruskal_minimum_spanning_tree(g, std::back_inserter(spanning_tree));

  int total_weight = 0;
  for (std::vector < Edge >::iterator ei = spanning_tree.begin();
       ei != spanning_tree.end(); ++ei) 
  {
    std::cout << letter[source(*ei, g)] << " <--> " << letter[target(*ei, g)]
      << " with weight of " << weight[*ei]
      << std::endl;
    total_weight += weight[*ei];
  }
  std::cout << "Total Weight = " << total_weight << std::endl;

  return EXIT_SUCCESS;
}

Answer 1

因此，您需要以最便宜的方式从Z向后进入每个节点。您的问题等同于在DAG上查找生成树，除了您需要转换DAG以使边指向相反方向。正如this answer中所述，您应该检查Chu–Liu/Edmonds' algorithm等算法。

然而，似乎Boost Graph中没有现成的算法。您可能需要构建自己的算法。

Answer 2

这是一个可以用Uniform Cost Search解决的问题。此算法可应用于包含至少一个解决方案的任何directed graph。

这将找到总边缘成本最低的路径。

如果您正在寻找覆盖最少节点数的路径，您需要Breadth First Search