greedy_algorithms Namespace Reference

for string class More...

Namespaces
namespace	dijkstra
	Functions for the Dijkstra algorithm implementation.
namespace	stable_matching
	Functions for the Gale-Shapley Algorithm.

Classes
class	BinaryAddition
	A class to perform binary addition of two binary strings. More...
class	DigitSeparation
	A class that provides methods to separate the digits of a large positive number. More...

Functions
bool	can_jump (const std::vector< int > &nums)
	Checks whether the given element (default is 1) can jump to the last index.
template<typename T , std::size_t N, std::size_t M>
void	findMinimumEdge (const T &infinity, const std::array< std::array< T, N >, M > &graph)
	Finds the minimum edge of the given graph.

Detailed Description

for string class

for uint32_t

Greedy Algorithms.

For std::vector to store separated digits.

for std::vector

for reverse function for tests for input and outputs

Greedy Algorithms

for assert for INT_MAX for IO operations

Greedy Algorithms

For reveresing the vector For assert() function to check for errors For abs() function For int64_t data type to handle large numbers For input/output operations

Greedy Algorithms

for std::find for assert for std::uint32_t for std::vector

for assert for std::cout

Greedy Algorithms

for array for IO operations for numeric limits

Greedy Algorithms

Function Documentation

can_jump()

bool greedy_algorithms::can_jump

(

const std::vector< int > &

nums

)

Checks whether the given element (default is 1) can jump to the last index.

Parameters

nums	array of numbers containing the maximum jump (in steps) from that index

Returns

true if the index can be reached

false if the index can NOT be reached

                                          {
    size_t lastPos = nums.size() - 1;
    for (size_t i = lastPos; i != static_cast<size_t>(-1); i--) {
        if (i + nums[i] >= lastPos) {
            lastPos = i;
        }
    }
    return lastPos == 0;
}

Here is the call graph for this function:

findMinimumEdge()

template<typename T , std::size_t N, std::size_t M>

void greedy_algorithms::findMinimumEdge	(	const T &	infinity,
		const std::array< std::array< T, N >, M > &	graph )

Finds the minimum edge of the given graph.

Parameters

infinity	Defines the infinity of the graph
graph	The graph that will be used to find the edge

Returns

void

                                                               {
    if (N != M) {
        std::cout << "\nWrong input passed. Provided array has dimensions " << N
                  << "x" << M << ". Please provide a square matrix.\n";
        return;
    }
    for (int i = 0; i < graph.size(); i++) {
        int min = infinity;
        int minIndex = 0;
        for (int j = 0; j < graph.size(); j++) {
            if (i != j && graph[i][j] != 0 && graph[i][j] < min) {
                min = graph[i][j];
                minIndex = j;
            }
        }
        std::cout << i << "  -  " << minIndex << "\t" << graph[i][minIndex]
                  << "\n";
    }
}