# fn() allPairsShortestPath
Finds shortest paths between all pairs of vertices in a graph.

Defined in | <seqan/graph_algorithms.h>
Signature | `void allPairsShortestPath(graph, weight, distance, predecessor);`

## Parameters

`distance` | A Matrix with distances. Entry `(i,j)` in this matrix indicates the distance from vertex `i` to vertex `j`.
`predecessor` | A Matrix with predecessors. Entry `(i,j)` in this matrix indicates the predecessor of `j` on a shortest path from vertex `i` to vertex `j`. You can use `_printAllPairsShortestPath(graph, predecessor, i, j)` to print the shortest path from `i` to `j`.
`graph` | A Directed Graph.
`weight` | A property map with edge weights. Edge weights may be negative.

## Detailed Description

### Example

    #include <iostream>
    #include <seqan/graph_algorithms.h>

    using namespace seqan;

    int main()
    {
        typedef Graph<Directed<> > TGraph;
        typedef VertexDescriptor<TGraph>::Type TVertexDescriptor;
        typedef Size<TGraph>::Type TSize;

        // Create a graph with 9 directed edges (0,1), (0,2), ...
        TSize numEdges = 9;
        TVertexDescriptor edges[] = {0, 1, 0, 2, 0, 4, 1, 3, 1, 4, 2, 1, 3, 0, 3, 2, 4, 3};
        TGraph g;
        addEdges(g, edges, numEdges);
        // Print graph.
        std::cout << g << std::endl;

        // Create a property map with edge weights.  Note that we can use negative
        // weights since the edges are directed and there are no cycles.
        int weights[] = {3, 8, -4, 1, 7, 4, 2, -5, 6};
        String<int> weightMap;
        assignEdgeMap(weightMap, g, weights);

        // Compute all-pairs shortest path.
        String<int> distMat;
        String<TVertexDescriptor> predMat;
        allPairsShortestPath(distMat, predMat, g, weightMap);

        // Print the result to stdout.
        unsigned int len = static_cast<unsigned>(std::sqrt((double)length(distMat)));
        for (TSize row = 0; row < len; ++row)
            for (TSize col = 0; col < len; ++col)
            {
                std::cout << row << "," << col << " (Distance="
                          << getValue(distMat, row * len + col) << "): ";
                _printAllPairsShortestPath(g, predMat, row, col);
                std::cout << "\n";
            }

        return 0;
    }

Demo: demos/dox/graph_algorithms/all_pairs_shortest_path.cpp

    Adjacency list:
    0 -> 4,2,1,
    1 -> 4,3,
    2 -> 1,
    3 -> 2,0,
    4 -> 3,
    Edge list:
    Source: 0,Target: 4 (Id: 2)
    Source: 0,Target: 2 (Id: 1)
    Source: 0,Target: 1 (Id: 0)
    Source: 1,Target: 4 (Id: 4)
    Source: 1,Target: 3 (Id: 3)
    Source: 2,Target: 1 (Id: 5)
    Source: 3,Target: 2 (Id: 7)
    Source: 3,Target: 0 (Id: 6)
    Source: 4,Target: 3 (Id: 8)

    0,0 (Distance=0): 0
    0,1 (Distance=1): 0,4,3,2,1
    0,2 (Distance=-3): 0,4,3,2
    0,3 (Distance=2): 0,4,3
    0,4 (Distance=-4): 0,4
    1,0 (Distance=3): 1,3,0
    1,1 (Distance=0): 1
    1,2 (Distance=-4): 1,3,2
    1,3 (Distance=1): 1,3
    1,4 (Distance=-1): 1,3,0,4
    2,0 (Distance=7): 2,1,3,0
    2,1 (Distance=4): 2,1
    2,2 (Distance=0): 2
    2,3 (Distance=5): 2,1,3
    2,4 (Distance=3): 2,1,3,0,4
    3,0 (Distance=2): 3,0
    3,1 (Distance=-1): 3,2,1
    3,2 (Distance=-5): 3,2
    3,3 (Distance=0): 3
    3,4 (Distance=-2): 3,0,4
    4,0 (Distance=8): 4,3,0
    4,1 (Distance=5): 4,3,2,1
    4,2 (Distance=1): 4,3,2
    4,3 (Distance=6): 4,3
    4,4 (Distance=0): 4

## Data Races

If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

## See Also

- floydWarshallAlgorithm

#### Dox Sources

    /*!
     * @fn allPairsShortestPath
     *
     * @headerfile <seqan/graph_algorithms.h>
     *
     * @brief Finds shortest paths between all pairs of vertices in a graph.
     *
     * @signature void allPairsShortestPath(graph, weight, distance, predecessor);
     *
     * @param[out] distance A @link Matrix @endlink with distances. Entry
     *                      <tt>(i,j)</tt> in this matrix indicates the distance
     *                      from vertex <tt>i</tt> to vertex <tt>j</tt>.
     * @param[out] predecessor A @link Matrix @endlink with predecessors. Entry
     *                         <tt>(i,j)</tt> in this matrix indicates the
     *                         predecessor of <tt>j</tt> on a shortest path from
     *                         vertex <tt>i</tt> to vertex <tt>j</tt>. You can use
     *                         <tt>_printAllPairsShortestPath(graph, predecessor, i,
     *                         j)</tt> to print the shortest path from <tt>i</tt> to
     *                         <tt>j</tt>.
     * @param[in] graph A @link DirectedGraph Directed Graph @endlink.
     * @param[in] weight A property map with edge weights. Edge weights may be
     *                   negative.
     *
     * @section Example
     *
     * @include demos/dox/graph_algorithms/all_pairs_shortest_path.cpp
     *
     * @include demos/dox/graph_algorithms/all_pairs_shortest_path.cpp.stdout
     *
     * @see floydWarshallAlgorithm
     */