# fn() primsAlgorithm
Computes a minimum spanning tree on a graph.

Defined in | <seqan/graph_algorithms.h>
Signature | `void primsAlgorithm(predecessor, g, source, weight);`

## Parameters

`predecessor` | A property map. A property map that represents predecessor relationships among vertices. It determines a minimum spanning tree.
`g` | An undirected graph. Types: Undirected Graph
`source` | A source vertex. Types: VertexDescriptor
`weight` | Edge weights.

## Detailed Description

### Example

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

    using namespace seqan;

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

        // Create graph with 14 undirected edges {0,1}, {0,6}, ...
        TSize numEdges = 14;
        TVertexDescriptor edges[] = {0, 1, 0, 6, 1, 2, 1, 6, 2, 3, 2, 4, 2, 8, 3, 5, 3, 8, 4, 6, 4, 7, 5, 8, 6, 7, 7, 8};
        TGraph g;
        addEdges(g, edges, numEdges);
        // Print graph.
        std::cout << g << std::endl;

        // Fill two external property maps for edge weights and vertex names.
        unsigned int weights[] = {4, 8, 8, 11, 7, 2, 4, 9, 14, 7, 6, 10, 1, 2};
        char names[] = {'a', 'b', 'c', 'd', 'i', 'e', 'h', 'g', 'f'};
        String<int> weightMap;
        assignEdgeMap(weightMap, g, weights);
        String<char> nameMap;
        assignVertexMap(nameMap, g, names);

        // Run Prim's algorithm.
        String<TVertexDescriptor> predMap;
        primsAlgorithm(predMap, g, 0, weightMap);

        // Print result to stdout.
        std::cout << "Minimum Spanning Tree (Prim's algorithm): \n";
        typedef Iterator<TGraph, VertexIterator>::Type TVertexIterator;
        TVertexIterator it(g);
        while (!atEnd(it))
        {
            std::cout << "Path from " << getProperty(nameMap, 0) << " to "
                      << getProperty(nameMap, getValue(it)) << ": ";
            _printPath(g, predMap, (TVertexDescriptor)0, getValue(it), nameMap);
            std::cout << "\n";
            goNext(it);
        }

        return 0;
    }

Demo: demos/dox/graph_algorithms/prims_algorithm.cpp

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

    Minimum Spanning Tree (Prim's algorithm):
    Path from a to a: a
    Path from a to b: a,b
    Path from a to c: a,b,c
    Path from a to d: a,b,c,d
    Path from a to i: a,b,c,i
    Path from a to e: a,b,c,d,e
    Path from a to h: a,b,c,f,g,h
    Path from a to g: a,b,c,f,g
    Path from a to f: a,b,c,f

## Data Races

Thread safety unknown!

## See Also

- kruskalsAlgorithm

#### Dox Sources

    /*!
     * @fn primsAlgorithm
     *
     * @headerfile <seqan/graph_algorithms.h>
     *
     * @brief Computes a minimum spanning tree on a graph.
     *
     * @signature void primsAlgorithm(predecessor, g, source, weight);
     *
     * @param[out] predecessor  A property map. A property map that represents
     *                         predecessor relationships among vertices. It
     *                         determines a minimum spanning tree.
     * @param[in] g An undirected graph. Types: Undirected Graph
     * @param[in] source A source vertex. Types: VertexDescriptor
     * @param[in] weight Edge weights.
     *
     * @section Example
     *
     * @include demos/dox/graph_algorithms/prims_algorithm.cpp
     *
     * @include demos/dox/graph_algorithms/prims_algorithm.cpp.stdout
     *
     * @see kruskalsAlgorithm
     */