
all_shortest_paths(+Graph, +DistanceArg, +SourceNode, -Paths)

   Computes all shortest paths from a single source to every reachable node

Arguments
   Graph               a graph structure
   DistanceArg         which argument of EdgeData to use as distance: integer
   SourceNode          source node number
   Paths               array of lists of Length-EdgeList structures

Type
   library(graph_algorithms)

Description

    Computes all shortest paths from the single source node SourceNode
    to every node which is reachable from it. For each such node pair,
    all minimal paths are returned in a list.

    DistanceArg refers to the graph's EdgeData information that was
    specified when the graph was constructed. If EdgeData is a simple
    number, then DistanceArg should be 0 and EdgeData will be taken
    as the length of the edge. If EdgeData is a compound data structure,
    DistanceArg should be a number between 1 and the arity of that
    structure and determines which argument of the EdgeData structure
    will be interpreted as the edge's length. Important: the distance
    information in EdgeData must be a non-negative number, and the
    numeric type (integer, float, etc) must be the same in all edges.

    If DistanceArg is given as -1, then any EdgeData is ignored and
    the length of every edge is assumed to be equal to 1.

    SourceNode is the common starting point for the computed paths.

    The results are returned as an array ranging over all node numbers.
    For unreachable nodes the array element is uninstantiated.
    For reachable nodes, the array element contains a list of all shortest
    paths from SourceNode to the reached node indicated by the array index.
    The list contains Length-EdgeList structures where Length is the
    length of the shortest path and EdgeList is such a path in reverse
    order, i.e. starting with the edge reaching the target and ending
    with the edge starting from SourceNode.
    

Examples
   
    ?- sample_graph(G), all_shortest_paths(G, 0, 1, P).
    P = []([2 - [e(2, 1, 1), e(1, 2, 1)]], [1 - [e(1, 2, 1)]], ...)
    

See Also
   shortest_paths / 4
