如何在DAG中找到两个顶点之间的最大权重路径？

Question

In a DAG G, with non negative weighted edges, how do you find the maximum-weight path between two vertices in G?

Thank you guys!

Answer 1

You can solve this in O(n + m) time (where n is the number of nodes and m the number of edges) using a topological sort. Begin by doing topological sort on the reverse graph, so that you have all the nodes ordered in a way such that no node is visited before all its children are visited.

Now, we're going to label all the nodes with the weight of the highest-weight path starting with that node. This is done based on the following recursive observation:

• The weight of the highest-weight path starting from a sink node (any node with no outgoing edges) is zero, since the only path starting from that node is the length-zero path of just that node.
• The weight of the highest-weight path starting from any other node is given by the maximum weight of any path formed by following an outgoing edge to a node, then taking the maximum-weight path from that node.

Because we have the nodes reverse-topologically sorted, we can visit all of the nodes in an order that guarantees that if we ever try following an edge and looking up the cost of the heaviest path at the endpoint of that node, we will have already computed the maximum-weight path starting at that node. This means that once we have the reverse topological sorted order, we can apply the following algorithm to all the nodes in that order:

1. If the node has no outgoing edges, record the weight of the heaviest path starting at that node (denoted d(u)) as zero.
2. Otherwise, for each edge (u, v) leaving the current node u, compute l(u, v) + d(v), and set d(u) to be the largest value attained this way.

Once we've done this step, we can make one last pass over all the nodes and return the highest value of d attained by any node.

The runtime of this algorithm can be analyzed as follows. Computing a topological sort can be done in O(n + m) time using many different methods. When we then scan over each node and each outgoing edge from each node, we visit each node and edge exactly once. This means that we spend O(n) time on the nodes and O(m) time on the edges. Finally, we spend O(n) time on one final pass over the elements to find the highest weight path, which takes O(n). This gives a grand total of O(n + m) time, which is linear in the size of the input.

Answer 2

A simple brute-force algorithm can be written using recursive functions. Start with an empty vector (in C++: std::vector) and insert the first node. Then call your recursive function with the vector as argument that does the following:

• loop over all neighbours and for each neighbour
  • copy the vector
  • add the neighbour
  • call ourself

Also add the total weight as argument to the recursive function and add the weight in every recursive call.

The function should stop whenever it reaches the end node. Then compare the total weight with the maximum weight you have so far (use a global variable) and if the new total weight is bigger, set the maximum weight and store the vector.

The rest is up to you.