/// <summary>
        /// Tries to compute the shortest paths in an unweighted graph with the Bellman-Ford's algorithm. Shortest paths are computed with the distance between the vertices. Returns true if successful; otherwise false.
        /// </summary>
        /// <typeparam name="TVertex">The data type of the vertices. TVertex implements <see cref="IComparable{T}"/>.</typeparam>
        /// <param name="graph">The graph structure that implements <see cref="IGraph{TVertex}"/>.</param>
        /// <param name="source">The source vertex for which the shortest paths are computed.</param>
        /// <param name="shortestPaths">The <see cref="UnweightedGraphShortestPaths{TVertex}"/> object that contains the shortest paths of the graph if the algorithm was successful; otherwise null.</param>
        /// <returns>Returns true if the shortest paths were successfully computed; otherwise false. Also returns false if the given source vertex does not belong to the graph.</returns>
        public static bool TryGetBellmanFordShortestPaths <TVertex>(this IGraph <TVertex> graph, TVertex source, out UnweightedGraphShortestPaths <TVertex> shortestPaths)
            where TVertex : IComparable <TVertex>
        {
            shortestPaths = null;

            if (!graph.ContainsVertex(source))
            {
                return(false);
            }

            // A dictionary holding a vertex as key and its previous vertex in the path as value.
            var previousVertices = new Dictionary <TVertex, TVertex>();
            // A dictionary holding a vertex as key and the distance from the source vertex as value.
            var pathDistance = new Dictionary <TVertex, int>();

            // Add source vertex to computed distances
            pathDistance.Add(source, 0);

            // Get all edges and sort them by their source and then by their destination vertex to create a consistent shortest paths output.
            var allEdges = graph.Edges.ToList();

            if (allEdges.Count > 0)
            {
                allEdges.QuickSort((x, y) =>
                {
                    int cmp = x.Source.CompareTo(y.Source);
                    if (cmp == 0)
                    {
                        cmp = x.Destination.CompareTo(y.Destination);
                    }
                    return(cmp);
                });
            }

            // We relax all edges n - 1 times and if at the n-th step a relaxation is needed we have a negative cycle
            int lastStep = graph.VerticesCount - 1;

            for (int i = 0; i < graph.VerticesCount; i++)
            {
                foreach (var edge in allEdges)
                {
                    var edgeSource      = edge.Source;
                    var edgeDestination = edge.Destination;

                    // If we have computed the path to the the source vertex of the edge
                    if (pathDistance.ContainsKey(edgeSource))
                    {
                        int curDistance = pathDistance[edgeSource];

                        // If the edge destination is the source we continue with the next edge
                        if (object.Equals(source, edgeDestination))
                        {
                            continue;
                        }

                        int newDistance = curDistance + 1;

                        // If this distance is bigger or equal than an already computed distance we continue with the next edge
                        if (pathDistance.ContainsKey(edgeDestination))
                        {
                            if (newDistance.CompareTo(pathDistance[edgeDestination]) >= 0)
                            {
                                continue;
                            }
                        }

                        if (i == lastStep)// if we need to relax on the last iteration we have a negative cycle
                        {
                            return(false);
                        }

                        // Else we save the path
                        previousVertices[edgeDestination] = edgeSource;
                        pathDistance[edgeDestination]     = newDistance;
                    }
                }
            }

            // Remove source vertex from path distance dictionary
            pathDistance.Remove(source);

            shortestPaths = new UnweightedGraphShortestPaths <TVertex>(source, previousVertices, pathDistance);
            return(true);
        }
        /// <summary>
        /// Uses Dijkstra's algorithm to compute the shortest paths in an unweighted graph. Shortest paths are computed with the distance between the vertices. Returns an <see cref="UnweightedGraphShortestPaths{TVertex}"/> object containg the shortest paths.
        /// </summary>
        /// <typeparam name="TVertex">The data type of the vertices. TVertex implements <see cref="IComparable{T}"/>.</typeparam>
        /// <param name="graph">The graph structure that implements <see cref="IGraph{TVertex}"/>.</param>
        /// <param name="source">The source vertex for which the shortest paths are computed.</param>
        /// <returns>Returns a <see cref="UnweightedGraphShortestPaths{TVertex}"/> containing the shortest paths for the given source vertex.</returns>
        public static UnweightedGraphShortestPaths <TVertex> DijkstraShortestPaths <TVertex>(this IGraph <TVertex> graph, TVertex source)
            where TVertex : IComparable <TVertex>
        {
            if (!graph.ContainsVertex(source))
            {
                throw new ArgumentException("Vertex does not belong to the graph!");
            }

            // A dictionary holding a vertex as key and its previous vertex in the path as value.
            var previousVertices = new Dictionary <TVertex, TVertex>();
            // A dictionary holding a vertex as key and the distance from the source vertex as value.
            var pathDistance = new Dictionary <TVertex, int>();
            // Comparer for the key-value pair in the sorted set
            var kvpComparer = Comparer <KeyValuePair <int, TVertex> > .Create((x, y) =>
            {
                var cmp = x.Key.CompareTo(y.Key);
                if (cmp == 0)
                {
                    cmp = x.Value.CompareTo(y.Value);
                }
                return(cmp);
            });

            // Sorted set containing the vertices for computing. Having a kvp with the distance from the source vertex as a key and the vertex as a value
            var priorityQueue = new MinPriorityQueue <int, TVertex>(kvpComparer);

            // Add the source vertex
            priorityQueue.Enqueue(0, source);

            while (priorityQueue.Count > 0)
            {
                var     curKVP      = priorityQueue.Dequeue();
                TVertex curVertex   = curKVP.Value;
                int     curDistance = curKVP.Key;

                foreach (var edge in graph.OutgoingEdgesSorted(curVertex))
                {
                    var edgeDestination = edge.Destination;

                    // If the edge destination is the source we continue with the next edge
                    if (object.Equals(source, edgeDestination))
                    {
                        continue;
                    }

                    int newDistance = curDistance + 1;

                    // If this distance is bigger or equal than an already computed distance we continue with the next edge
                    if (pathDistance.ContainsKey(edgeDestination))
                    {
                        if (newDistance.CompareTo(pathDistance[edgeDestination]) >= 0)
                        {
                            continue;
                        }
                    }

                    // Else we save the path
                    previousVertices[edgeDestination] = curVertex;
                    pathDistance[edgeDestination]     = newDistance;

                    // Add the destination vertex for computing
                    priorityQueue.Enqueue(newDistance, edgeDestination);
                }
            }

            var shortestPaths = new UnweightedGraphShortestPaths <TVertex>(source, previousVertices, pathDistance);

            return(shortestPaths);
        }