Is there an algorithm to find the minimum cost path in a directed rooted tree (arborescence)?

Question

To be more specific : I have a rooted tree which represents the different paths of a matrix from its first element to its last, with only right, down and diagonal down movements allowed. Hence, every node can have up to 3 children. The tree will have the first element of the matrix as its root and every last node will be the last element of the matrix. Every node represents a cost.

Here's an example of what kind of tree I'm talking about :

Here the minimum cost path would be : 1 -> 2 -> 9 or [0,0,2] in "coordinates"

So is there any algorithm that is able to find the minimum cost path (I mean the path not the total cost of the minimum cost path) for this kind of tree ?
And if yes, is it possible to implement it in a recursive way ?

kaya3 · Accepted Answer · 2019-12-14T03:59:55.130

This can be done in O(n) time, where n is the number of nodes. The solution is recursive:

The minimum cost path for a leaf node is trivial - it is just the node itself, with the node's own cost.
To find the minimum cost path for an internal node, make recursive calls on all its children, and select whichever child node has the lowest cost for its minimum cost path. The cost of the path equals the node's own cost plus the cost of the path for that child.

To recover the path, simply return both the cost and the path from the function. The recursive case has to extend the path with the current node.

The total running time is O(n) because the non-recursive work done for an internal node is proportional to the number of children. The running time cannot be improved on asymptotically, but it could be optimised in practice using a branch-and-bound algorithm which keeps track of the lowest cost path so far, and rejecting paths which exceed it.

Here's an example in Python:

class Node:
    def __init__(self, cost, children=()):
        self.cost = cost
        self.children = children
    def __repr__(self):
        return 'Node({})'.format(self.cost)

root = Node(1, (
    Node(2, (
        Node(5, (Node(9),)),
        Node(6, (Node(9),)),
        Node(9),
    )),
    Node(3, (
        Node(8, (Node(9),)),
        Node(9),
    )),
    Node(4, (Node(9),)),
))

def min_cost_path(node):
    if not node.children:
        return [node], node.cost
    else:
        # list of (path, cost) pairs
        options = [min_cost_path(c) for c in node.children]
        path, cost = min(options, key=lambda option: option[1])
        path.append(node)
        return path, cost + node.cost

Example:

>>> path, cost = min_cost_path(root)
>>> path
[Node(9), Node(2), Node(1)]
>>> cost
12

Note that the path is returned in reverse order.

Incredible! It's seems so simple now... The example with Python helped a lot. Thank you very much. — hamanic, Dec 14 '19 at 04:18
Glad to help. Since you mentioned these are paths in a matrix, I assume the nodes of cost 9 all represent the same matrix cell; in that case, you can model it as a directed acyclic graph rather than a tree, and there is no need to recompute the path/cost for the same matrix cells multiple times; you can cache the results in the node objects themselves, and return the cached results if they exist. This substantially reduces the running time for large matrices where there are many paths reaching the same cells. — kaya3, Dec 14 '19 at 04:26

Is there an algorithm to find the minimum cost path in a directed rooted tree (arborescence)?

1 Answers1