OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into strassen-multiplication

Browse Source
This commit is contained in:
David Leal 2023-01-24 13:59:25 -06:00 committed by GitHub
commit 0545555a7f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 844 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
DIRECTORY.md
View File

@ -20,6 +20,7 @@
* [Find Non Repeating Number](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/find_non_repeating_number.cpp)
* [Hamming Distance](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/hamming_distance.cpp)
* [Set Kth Bit](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/set_kth_bit.cpp)
* [Travelling Salesman Using Bit Manipulation](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/bit_manipulation/travelling_salesman_using_bit_manipulation.cpp)
## Ciphers
* [A1Z26 Cipher](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/ciphers/a1z26_cipher.cpp)
@ -66,7 +67,7 @@
* [Reverse A Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/data_structures/reverse_a_linked_list.cpp)
* [Skip List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/data_structures/skip_list.cpp)
* [Sparse Table](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/data_structures/sparse_table.cpp)
* [Stack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/data_structures/stack.h)
* [Stack](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/data_structures/stack.hpp)
* [Stack Using Array](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/data_structures/stack_using_array.cpp)
* [Stack Using Linked List](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/data_structures/stack_using_linked_list.cpp)
* [Stack Using Queue](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/data_structures/stack_using_queue.cpp)

119
bit_manipulation/travelling_salesman_using_bit_manipulation.cpp Normal file
View File

@ -0,0 +1,119 @@
/**
* @file
* @brief Implementation to
* [Travelling Salesman problem using bit-masking]
* (https://www.geeksforgeeks.org/travelling-salesman-problem-set-1/)
*
* @details
* Given the distance/cost(as and adjacency matrix) between each city/node to the other city/node ,
* the problem is to find the shortest possible route that visits every city exactly once
* and returns to the starting point or we can say the minimum cost of whole tour.
*
* Explanation:
* INPUT -> You are given with a adjacency matrix A = {} which contains the distance between two cities/node.
*
* OUTPUT -> Minimum cost of whole tour from starting point
*
* Worst Case Time Complexity: O(n^2 * 2^n)
* Space complexity: O(n)
* @author [Utkarsh Yadav](https://github.com/Rytnix)
*/
#include <algorithm> /// for std::min
#include <cassert> /// for assert
#include <iostream> /// for IO operations
#include <vector> /// for std::vector
#include <limits> /// for limits of integral types
/**
* @namespace bit_manipulation
* @brief Bit manipulation algorithms
*/
namespace bit_manipulation {
/**
* @namespace travellingSalesman_bitmanipulation
* @brief Functions for the [Travelling Salesman
* Bitmask](https://www.geeksforgeeks.org/travelling-salesman-problem-set-1/)
* implementation
*/
namespace travelling_salesman_using_bit_manipulation {
/**
* @brief The function implements travellingSalesman using bitmanipulation
* @param dist is the cost to reach between two cities/nodes
* @param setOfCitites represents the city in bit form.\
* @param city is taken to track the current city movement.
* @param n is the no of citys .
* @param dp vector is used to keep a record of state to avoid the recomputation.
* @returns minimum cost of traversing whole nodes/cities from starting point back to starting point
*/
std::uint64_t travelling_salesman_using_bit_manipulation(std::vector<std::vector<uint32_t>> dist, // dist is the adjacency matrix containing the distance.
// setOfCities as a bit represent the cities/nodes. Ex: if setOfCities = 2 => 0010(in binary)
// means representing the city/node B if city/nodes are represented as D->C->B->A.
std::uint64_t setOfCities,
std::uint64_t city, // city is taken to track our current city/node movement,where we are currently.
std::uint64_t n, // n is the no of cities we have.
std::vector<std::vector<uint32_t>> &dp) //dp is taken to memorize the state to avoid recomputition
{
//base case;
if (setOfCities == (1 << n) - 1) // we have covered all the cities
return dist[city][0]; //return the cost from the current city to the original city.
if (dp[setOfCities][city] != -1)
return dp[setOfCities][city];
//otherwise try all possible options
uint64_t ans = 2147483647 ;
for (int choice = 0; choice < n; choice++) {
//check if the city is visited or not.
if ((setOfCities & (1 << choice)) == 0 ) { // this means that this perticular city is not visited.
std::uint64_t subProb = dist[city][choice] + travelling_salesman_using_bit_manipulation(dist, setOfCities | (1 << choice), choice, n, dp);
// Here we are doing a recursive call to tsp with the updated set of city/node
// and choice which tells that where we are currently.
ans = std::min(ans, subProb);
}
}
dp[setOfCities][city] = ans;
return ans;
}
} // namespace travelling_salesman_using_bit_manipulation
} // namespace bit_manipulation
/**
* @brief Self-test implementations
* @returns void
*/
static void test() {
// 1st test-case
std::vector<std::vector<uint32_t>> dist = {
{0, 20, 42, 35}, {20, 0, 30, 34}, {42, 30, 0, 12}, {35, 34, 12, 0}
};
uint32_t V = dist.size();
std::vector<std::vector<uint32_t>> dp(1 << V, std::vector<uint32_t>(V, -1));
assert(bit_manipulation::travelling_salesman_using_bit_manipulation::travelling_salesman_using_bit_manipulation(dist, 1, 0, V, dp) == 97);
std::cout << "1st test-case: passed!" << "\n";
// 2nd test-case
dist = {{0, 5, 10, 15}, {5, 0, 20, 30}, {10, 20, 0, 35}, {15, 30, 35, 0}};
V = dist.size();
std::vector<std::vector<uint32_t>> dp1(1 << V, std::vector<uint32_t>(V, -1));
assert(bit_manipulation::travelling_salesman_using_bit_manipulation::travelling_salesman_using_bit_manipulation(dist, 1, 0, V, dp1) == 75);
std::cout << "2nd test-case: passed!" << "\n";
// 3rd test-case
dist = {
{0, 10, 15, 20}, {10, 0, 35, 25}, {15, 35, 0, 30}, {20, 25, 30, 0}
};
V = dist.size();
std::vector<std::vector<uint32_t>> dp2(1 << V, std::vector<uint32_t>(V, -1));
assert(bit_manipulation::travelling_salesman_using_bit_manipulation::travelling_salesman_using_bit_manipulation(dist, 1, 0, V, dp2) == 80);
std::cout << "3rd test-case: passed!" << "\n";
}
/**
* @brief Main function
* @returns 0 on exit
*/
int main() {
test(); // run self-test implementations
return 0;
}

150
data_structures/stack.h
View File

@ -1,150 +0,0 @@
/**
* @file stack.h
* @author danghai
* @brief This class specifies the basic operation on a stack as a linked list
**/
#ifndef DATA_STRUCTURES_STACK_H_
#define DATA_STRUCTURES_STACK_H_
#include <cassert>
#include <iostream>
/** Definition of the node as a linked-list
* \tparam Type type of data nodes of the linked list should contain
*/
template <class Type>
struct node {
Type data; ///< data at current node
node<Type> *next; ///< pointer to the next ::node instance
};
/** Definition of the stack class
* \tparam Type type of data nodes of the linked list in the stack should
* contain
*/
template <class Type>
class stack {
public:
/** Show stack */
void display() {
node<Type> *current = stackTop;
std::cout << "Top --> ";
while (current != nullptr) {
std::cout << current->data << " ";
current = current->next;
}
std::cout << std::endl;
std::cout << "Size of stack: " << size << std::endl;
}
/** Default constructor*/
stack() {
stackTop = nullptr;
size = 0;
}
/** Copy constructor*/
explicit stack(const stack<Type> &otherStack) {
node<Type> *newNode, *current, *last;
/* If stack is no empty, make it empty */
if (stackTop != nullptr) {
stackTop = nullptr;
}
if (otherStack.stackTop == nullptr) {
stackTop = nullptr;
} else {
current = otherStack.stackTop;
stackTop = new node<Type>;
stackTop->data = current->data;
stackTop->next = nullptr;
last = stackTop;
current = current->next;
/* Copy the remaining stack */
while (current != nullptr) {
newNode = new node<Type>;
newNode->data = current->data;
newNode->next = nullptr;
last->next = newNode;
last = newNode;
current = current->next;
}
}
size = otherStack.size;
}
/** Destructor */
~stack() {}
/** Determine whether the stack is empty */
bool isEmptyStack() { return (stackTop == nullptr); }
/** Add new item to the stack */
void push(Type item) {
node<Type> *newNode;
newNode = new node<Type>;
newNode->data = item;
newNode->next = stackTop;
stackTop = newNode;
size++;
}
/** Return the top element of the stack */
Type top() {
assert(stackTop != nullptr);
return stackTop->data;
}
/** Remove the top element of the stack */
void pop() {
node<Type> *temp;
if (!isEmptyStack()) {
temp = stackTop;
stackTop = stackTop->next;
delete temp;
size--;
} else {
std::cout << "Stack is empty !" << std::endl;
}
}
/** Clear stack */
void clear() { stackTop = nullptr; }
/** Overload "=" the assignment operator */
stack<Type> &operator=(const stack<Type> &otherStack) {
node<Type> *newNode, *current, *last;
/* If stack is no empty, make it empty */
if (stackTop != nullptr) {
stackTop = nullptr;
}
if (otherStack.stackTop == nullptr) {
stackTop = nullptr;
} else {
current = otherStack.stackTop;
stackTop = new node<Type>;
stackTop->data = current->data;
stackTop->next = nullptr;
last = stackTop;
current = current->next;
/* Copy the remaining stack */
while (current != nullptr) {
newNode = new node<Type>;
newNode->data = current->data;
newNode->next = nullptr;
last->next = newNode;
last = newNode;
current = current->next;
}
}
size = otherStack.size;
return *this;
}
private:
node<Type> *stackTop; /**< Pointer to the stack */
int size; ///< size of stack
};
#endif // DATA_STRUCTURES_STACK_H_

106
data_structures/stack.hpp Normal file
View File

@ -0,0 +1,106 @@
/**
* @file
* @author danghai
* @author [Piotr Idzik](https://github.com/vil02)
* @brief This class specifies the basic operation on a stack as a linked list
**/
#ifndef DATA_STRUCTURES_STACK_HPP_
#define DATA_STRUCTURES_STACK_HPP_
#include <iostream> /// for IO operations
#include <memory> /// for std::shared_ptr
#include <stdexcept> /// for std::invalid_argument
#include <vector> /// for std::vector
/** Definition of the node as a linked-list
* \tparam ValueType type of data nodes of the linked list should contain
*/
template <class ValueType>
struct node {
ValueType data = {}; ///< data at current node
std::shared_ptr<node<ValueType>> next =
{}; ///< pointer to the next ::node instance
};
template <typename Node, typename Action>
void traverse(const Node* const inNode, const Action& action) {
if (inNode) {
action(*inNode);
traverse(inNode->next.get(), action);
}
}
/** Definition of the stack class
* \tparam value_type type of data nodes of the linked list in the stack should
* contain
*/
template <class ValueType>
class stack {
public:
using value_type = ValueType;
/** Show stack */
void display() const {
std::cout << "Top --> ";
traverse(stackTop.get(), [](const node<value_type>& inNode) {
std::cout << inNode.data << " ";
});
std::cout << std::endl;
std::cout << "Size of stack: " << size << std::endl;
}
std::vector<value_type> toVector() const {
std::vector<value_type> res;
res.reserve(this->size);
traverse(stackTop.get(), [&res](const node<value_type>& inNode) {
res.push_back(inNode.data);
});
return res;
}
private:
void ensureNotEmpty() const {
if (isEmptyStack()) {
throw std::invalid_argument("Stack is empty.");
}
}
public:
/** Determine whether the stack is empty */
bool isEmptyStack() const { return (stackTop == nullptr); }
/** Add new item to the stack */
void push(const value_type& item) {
auto newNode = std::make_shared<node<value_type>>();
newNode->data = item;
newNode->next = stackTop;
stackTop = newNode;
size++;
}
/** Return the top element of the stack */
value_type top() const {
ensureNotEmpty();
return stackTop->data;
}
/** Remove the top element of the stack */
void pop() {
ensureNotEmpty();
stackTop = stackTop->next;
size--;
}
/** Clear stack */
void clear() {
stackTop = nullptr;
size = 0;
}
private:
std::shared_ptr<node<value_type>> stackTop =
{}; /**< Pointer to the stack */
std::size_t size = 0; ///< size of stack
};
#endif // DATA_STRUCTURES_STACK_HPP_

252
data_structures/test_stack.cpp
View File

@ -1,59 +1,203 @@
#include <iostream>
#include <cassert> /// for assert
#include <iostream> /// for std::cout
#include <stdexcept> /// std::invalid_argument
#include <vector> /// for std::vector
#include "./stack.h"
#include "./stack.hpp"
template <typename T>
void testConstructedStackIsEmpty() {
const stack<T> curStack;
assert(curStack.isEmptyStack());
}
void testPush() {
using valueType = int;
stack<valueType> curStack;
curStack.push(10);
curStack.push(20);
curStack.push(30);
curStack.push(40);
const auto expectedData = std::vector<valueType>({40, 30, 20, 10});
assert(curStack.toVector() == expectedData);
}
void testTop() {
using valueType = unsigned;
stack<valueType> curStack;
curStack.push(1);
curStack.push(2);
curStack.push(3);
curStack.push(4);
assert(curStack.top() == static_cast<valueType>(4));
}
void testPop() {
using valueType = int;
stack<valueType> curStack;
curStack.push(100);
curStack.push(200);
curStack.push(300);
assert(curStack.top() == static_cast<valueType>(300));
curStack.pop();
assert(curStack.top() == static_cast<valueType>(200));
curStack.pop();
assert(curStack.top() == static_cast<valueType>(100));
curStack.pop();
assert(curStack.isEmptyStack());
}
void testClear() {
stack<int> curStack;
curStack.push(1000);
curStack.push(2000);
curStack.clear();
assert(curStack.isEmptyStack());
}
void testCopyOfStackHasSameData() {
stack<int> stackA;
stackA.push(10);
stackA.push(200);
stackA.push(3000);
const auto stackB(stackA);
assert(stackA.toVector() == stackB.toVector());
}
void testPushingToCopyDoesNotChangeOriginal() {
using valueType = int;
stack<valueType> stackA;
stackA.push(10);
stackA.push(20);
stackA.push(30);
auto stackB(stackA);
stackB.push(40);
const auto expectedDataA = std::vector<valueType>({30, 20, 10});
const auto expectedDataB = std::vector<valueType>({40, 30, 20, 10});
assert(stackA.toVector() == expectedDataA);
assert(stackB.toVector() == expectedDataB);
}
void testPoppingFromCopyDoesNotChangeOriginal() {
using valueType = int;
stack<valueType> stackA;
stackA.push(10);
stackA.push(20);
stackA.push(30);
auto stackB(stackA);
stackB.pop();
const auto expectedDataA = std::vector<valueType>({30, 20, 10});
const auto expectedDataB = std::vector<valueType>({20, 10});
assert(stackA.toVector() == expectedDataA);
assert(stackB.toVector() == expectedDataB);
}
void testPushingToOrginalDoesNotChangeCopy() {
using valueType = int;
stack<valueType> stackA;
stackA.push(10);
stackA.push(20);
stackA.push(30);
const auto stackB(stackA);
stackA.push(40);
const auto expectedDataA = std::vector<valueType>({40, 30, 20, 10});
const auto expectedDataB = std::vector<valueType>({30, 20, 10});
assert(stackA.toVector() == expectedDataA);
assert(stackB.toVector() == expectedDataB);
}
void testPoppingFromOrginalDoesNotChangeCopy() {
using valueType = int;
stack<valueType> stackA;
stackA.push(10);
stackA.push(20);
stackA.push(30);
const auto stackB(stackA);
stackA.pop();
const auto expectedDataA = std::vector<valueType>({20, 10});
const auto expectedDataB = std::vector<valueType>({30, 20, 10});
assert(stackA.toVector() == expectedDataA);
assert(stackB.toVector() == expectedDataB);
}
void testAssign() {
using valueType = int;
stack<valueType> stackA;
stackA.push(10);
stackA.push(20);
stackA.push(30);
stack<valueType> stackB = stackA;
stackA.pop();
stackB.push(40);
const auto expectedDataA = std::vector<valueType>({20, 10});
const auto expectedDataB = std::vector<valueType>({40, 30, 20, 10});
assert(stackA.toVector() == expectedDataA);
assert(stackB.toVector() == expectedDataB);
stackB = stackA;
stackA.pop();
stackB.push(5);
stackB.push(6);
const auto otherExpectedDataA = std::vector<valueType>({10});
const auto otherExpectedDataB = std::vector<valueType>({6, 5, 20, 10});
assert(stackA.toVector() == otherExpectedDataA);
assert(stackB.toVector() == otherExpectedDataB);
}
void testTopThrowsAnvalidArgumentWhenStackEmpty() {
const stack<long double> curStack;
bool wasException = false;
try {
curStack.top();
} catch (const std::invalid_argument&) {
wasException = true;
}
assert(wasException);
}
void testPopThrowsAnvalidArgumentWhenStackEmpty() {
stack<bool> curStack;
bool wasException = false;
try {
curStack.pop();
} catch (const std::invalid_argument&) {
wasException = true;
}
assert(wasException);
}
int main() {
stack<int> stk;
std::cout << "---------------------- Test construct ----------------------"
<< std::endl;
stk.display();
std::cout
<< "---------------------- Test isEmptyStack ----------------------"
<< std::endl;
if (stk.isEmptyStack())
std::cout << "PASS" << std::endl;
else
std::cout << "FAIL" << std::endl;
std::cout << "---------------------- Test push ----------------------"
<< std::endl;
std::cout << "After pushing 10 20 30 40 into stack: " << std::endl;
stk.push(10);
stk.push(20);
stk.push(30);
stk.push(40);
stk.display();
std::cout << "---------------------- Test top ----------------------"
<< std::endl;
int value = stk.top();
if (value == 40)
std::cout << "PASS" << std::endl;
else
std::cout << "FAIL" << std::endl;
std::cout << "---------------------- Test pop ----------------------"
<< std::endl;
stk.display();
stk.pop();
stk.pop();
std::cout << "After popping 2 times: " << std::endl;
stk.display();
std::cout << "---------------------- Test overload = operator "
"----------------------"
<< std::endl;
stack<int> stk1;
std::cout << "stk current: " << std::endl;
stk.display();
std::cout << std::endl << "Assign stk1 = stk " << std::endl;
stk1 = stk;
stk1.display();
std::cout << std::endl << "After pushing 8 9 10 into stk1:" << std::endl;
stk1.push(8);
stk1.push(9);
stk1.push(10);
stk1.display();
std::cout << std::endl << "stk current: " << std::endl;
stk.display();
std::cout << "Assign back stk = stk1:" << std::endl;
stk = stk1;
stk.display();
testConstructedStackIsEmpty<int>();
testConstructedStackIsEmpty<char>();
testPush();
testPop();
testClear();
testCopyOfStackHasSameData();
testPushingToCopyDoesNotChangeOriginal();
testPoppingFromCopyDoesNotChangeOriginal();
testPushingToOrginalDoesNotChangeCopy();
testPoppingFromOrginalDoesNotChangeCopy();
testAssign();
testTopThrowsAnvalidArgumentWhenStackEmpty();
testPopThrowsAnvalidArgumentWhenStackEmpty();
std::cout << "All tests pass!\n";
return 0;
}

7
data_structures/test_stack_students.cpp
View File

@ -9,16 +9,17 @@
************************************************************
* */
#include <cassert>
#include <cmath>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
#include "./stack.h"
#include "./stack.hpp"
int main(int argc, char* argv[]) {
double GPA;
double highestGPA;
double GPA = NAN;
double highestGPA = NAN;
std::string name;
assert(argc == 2);

125
dynamic_programming/subset_sum.cpp Normal file
View File

@ -0,0 +1,125 @@
/**
* @file
* @brief Implements [Sub-set sum problem]
* (https://en.wikipedia.org/wiki/Subset_sum_problem) algorithm, which tells
* whether a subset with target sum exists or not.
*
* @details
* In this problem, we use dynamic programming to find if we can pull out a
* subset from an array whose sum is equal to a given target sum. The overall
* time complexity of the problem is O(n * targetSum) where n is the size of
* the array. For example, array = [1, -10, 2, 31, -6], targetSum = -14.
* Output: true => We can pick subset [-10, 2, -6] with sum as
* (-10) + 2 + (-6) = -14.
* @author [KillerAV](https://github.com/KillerAV)
*/
#include <cassert> /// for std::assert
#include <iostream> /// for IO operations
#include <vector> /// for std::vector
#include <unordered_map> /// for unordered map
/**
* @namespace dynamic_programming
* @brief Dynamic Programming algorithms
*/
namespace dynamic_programming {
/**
* @namespace subset_sum
* @brief Functions for [Sub-set sum problem]
* (https://en.wikipedia.org/wiki/Subset_sum_problem) algorithm
*/
namespace subset_sum {
/**
* Recursive function using dynamic programming to find if the required sum
* subset exists or not.
* @param arr input array
* @param targetSum the target sum of the subset
* @param dp the map storing the results
* @returns true/false based on if the target sum subset exists or not.
*/
bool subset_sum_recursion(
const std::vector<int> &arr,
int targetSum,
std::vector<std::unordered_map<int, bool>> *dp,
int index = 0) {
if(targetSum == 0) { // Found a valid subset with required sum.
return true;
}
if(index == arr.size()) { // End of array
return false;
}
if ((*dp)[index].count(targetSum)) { // Answer already present in map
return (*dp)[index][targetSum];
}
bool ans = subset_sum_recursion(arr, targetSum - arr[index], dp, index + 1)
|| subset_sum_recursion(arr, targetSum, dp, index + 1);
(*dp)[index][targetSum] = ans; // Save ans in dp map.
return ans;
}
/**
* Function implementing subset sum algorithm using top-down approach
* @param arr input array
* @param targetSum the target sum of the subset
* @returns true/false based on if the target sum subset exists or not.
*/
bool subset_sum_problem(const std::vector<int> &arr, const int targetSum) {
size_t n = arr.size();
std::vector<std::unordered_map<int, bool>> dp(n);
return subset_sum_recursion(arr, targetSum, &dp);
}
} // namespace subset_sum
} // namespace dynamic_programming
/**
* @brief Test Function
* @return void
*/
static void test() {
// custom input vector
std::vector<std::vector<int>> custom_input_arr(3);
custom_input_arr[0] = std::vector<int> {1, -10, 2, 31, -6};
custom_input_arr[1] = std::vector<int> {2, 3, 4};
custom_input_arr[2] = std::vector<int> {0, 1, 0, 1, 0};
std::vector<int> custom_input_target_sum(3);
custom_input_target_sum[0] = -14;
custom_input_target_sum[1] = 10;
custom_input_target_sum[2] = 2;
// calculated output vector by pal_part Function
std::vector<int> calculated_output(3);
for (int i = 0; i < 3; i++) {
calculated_output[i] =
dynamic_programming::subset_sum::subset_sum_problem(
custom_input_arr[i], custom_input_target_sum[i]);
}
// expected output vector
std::vector<bool> expected_output{true, false, true};
// Testing implementation via assert function
// It will throw error if any of the expected test fails
// Else it will give nothing
for (int i = 0; i < 3; i++) {
assert(expected_output[i] == calculated_output[i]);
}
std::cout << "All tests passed successfully!\n";
}
/**
* @brief Main function
* @returns 0 on exit
*/
int main() {
test(); // execute the test
return 0;
}

222
greedy_algorithms/boruvkas_minimum_spanning_tree.cpp Normal file
View File

@ -0,0 +1,222 @@
/**
* @author [Jason Nardoni](https://github.com/JNardoni)
* @file
*
* @brief
* [Borůvkas Algorithm](https://en.wikipedia.org/wiki/Borůvka's_algorithm) to find the Minimum Spanning Tree
*
*
* @details
* Boruvka's algorithm is a greepy algorithm to find the MST by starting with small trees, and combining
* them to build bigger ones.
* 1. Creates a group for every vertex.
* 2. looks through each edge of every vertex for the smallest weight. Keeps track
* of the smallest edge for each of the current groups.
* 3. Combine each group with the group it shares its smallest edge, adding the smallest
* edge to the MST.
* 4. Repeat step 2-3 until all vertices are combined into a single group.
*
* It assumes that the graph is connected. Non-connected edges can be represented using 0 or INT_MAX
*
*/
#include <iostream> /// for IO operations
#include <vector> /// for std::vector
#include <cassert> /// for assert
#include <climits> /// for INT_MAX
/**
* @namespace greedy_algorithms
* @brief Greedy Algorithms
*/
namespace greedy_algorithms {
/**
* @namespace boruvkas_minimum_spanning_tree
* @brief Functions for the [Borůvkas Algorithm](https://en.wikipedia.org/wiki/Borůvka's_algorithm) implementation
*/
namespace boruvkas_minimum_spanning_tree {
/**
* @brief Recursively returns the vertex's parent at the root of the tree
* @param parent the array that will be checked
* @param v vertex to find parent of
* @returns the parent of the vertex
*/
int findParent(std::vector<std::pair<int,int>> parent, const int v) {
if (parent[v].first != v) {
parent[v].first = findParent(parent, parent[v].first);
}
return parent[v].first;
}
/**
* @brief the implementation of boruvka's algorithm
* @param adj a graph adjancency matrix stored as 2d vectors.
* @returns the MST as 2d vectors
*/
std::vector<std::vector<int>> boruvkas(std::vector<std::vector<int>> adj) {
size_t size = adj.size();
size_t total_groups = size;
if (size <= 1) {
return adj;
}
// Stores the current Minimum Spanning Tree. As groups are combined, they are added to the MST
std::vector<std::vector<int>> MST(size, std::vector<int>(size, INT_MAX));
for (int i = 0; i < size; i++) {
MST[i][i] = 0;
}
// Step 1: Create a group for each vertex
// Stores the parent of the vertex and its current depth, both initialized to 0
std::vector<std::pair<int, int>> parent(size, std::make_pair(0, 0));
for (int i = 0; i < size; i++) {
parent[i].first = i; // Sets parent of each vertex to itself, depth remains 0
}
// Repeat until all are in a single group
while (total_groups > 1) {
std::vector<std::pair<int,int>> smallest_edge(size, std::make_pair(-1, -1)); //Pairing: start node, end node
// Step 2: Look throught each vertex for its smallest edge, only using the right half of the adj matrix
for (int i = 0; i < size; i++) {
for (int j = i+1; j < size; j++) {
if (adj[i][j] == INT_MAX || adj[i][j] == 0) { // No connection
continue;
}
// Finds the parents of the start and end points to make sure they arent in the same group
int parentA = findParent(parent, i);
int parentB = findParent(parent, j);
if (parentA != parentB) {
// Grabs the start and end points for the first groups current smallest edge
int start = smallest_edge[parentA].first;
int end = smallest_edge[parentA].second;
// If there is no current smallest edge, or the new edge is smaller, records the new smallest
if (start == -1 || adj [i][j] < adj[start][end]) {
smallest_edge[parentA].first = i;
smallest_edge[parentA].second = j;
}
// Does the same for the second group
start = smallest_edge[parentB].first;
end = smallest_edge[parentB].second;
if (start == -1 || adj[j][i] < adj[start][end]) {
smallest_edge[parentB].first = j;
smallest_edge[parentB].second = i;
}
}
}
}
// Step 3: Combine the groups based off their smallest edge
for (int i = 0; i < size; i++) {
// Makes sure the smallest edge exists
if (smallest_edge[i].first != -1) {
// Start and end points for the groups smallest edge
int start = smallest_edge[i].first;
int end = smallest_edge[i].second;
// Parents of the two groups - A is always itself
int parentA = i;
int parentB = findParent(parent, end);
// Makes sure the two nodes dont share the same parent. Would happen if the two groups have been
//merged previously through a common shortest edge
if (parentA == parentB) {
continue;
}
// Tries to balance the trees as much as possible as they are merged. The parent of the shallower
//tree will be pointed to the parent of the deeper tree.
if (parent[parentA].second < parent[parentB].second) {
parent[parentB].first = parentA; //New parent
parent[parentB].second++; //Increase depth
}
else {
parent[parentA].first = parentB;
parent[parentA].second++;
}
// Add the connection to the MST, using both halves of the adj matrix
MST[start][end] = adj[start][end];
MST[end][start] = adj[end][start];
total_groups--; // one fewer group
}
}
}
return MST;
}
/**
* @brief counts the sum of edges in the given tree
* @param adj 2D vector adjacency matrix
* @returns the int size of the tree
*/
int test_findGraphSum(std::vector<std::vector<int>> adj) {
size_t size = adj.size();
int sum = 0;
//Moves through one side of the adj matrix, counting the sums of each edge
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (adj[i][j] < INT_MAX) {
sum += adj[i][j];
}
}
}
return sum;
}
} // namespace boruvkas_minimum_spanning_tree
} // namespace greedy_algorithms
/**
* @brief Self-test implementations
* @returns void
*/
static void tests() {
std::cout << "Starting tests...\n\n";
std::vector<std::vector<int>> graph = {
{0, 5, INT_MAX, 3, INT_MAX} ,
{5, 0, 2, INT_MAX, 5} ,
{INT_MAX, 2, 0, INT_MAX, 3} ,
{3, INT_MAX, INT_MAX, 0, INT_MAX} ,
{INT_MAX, 5, 3, INT_MAX, 0} ,
};
std::vector<std::vector<int>> MST = greedy_algorithms::boruvkas_minimum_spanning_tree::boruvkas(graph);
assert(greedy_algorithms::boruvkas_minimum_spanning_tree::test_findGraphSum(MST) == 13);
std::cout << "1st test passed!" << std::endl;
graph = {
{ 0, 2, 0, 6, 0 },
{ 2, 0, 3, 8, 5 },
{ 0, 3, 0, 0, 7 },
{ 6, 8, 0, 0, 9 },
{ 0, 5, 7, 9, 0 }
};
MST = greedy_algorithms::boruvkas_minimum_spanning_tree::boruvkas(graph);
assert(greedy_algorithms::boruvkas_minimum_spanning_tree::test_findGraphSum(MST) == 16);
std::cout << "2nd test passed!" << std::endl;
}
/**
* @brief Main function
* @returns 0 on exit
*/
int main() {
tests(); // run self-test implementations
return 0;
}

68
math/aliquot_sum.cpp Normal file
View File

@ -0,0 +1,68 @@
/**
* @file
* @brief Program to return the [Aliquot
* Sum](https://en.wikipedia.org/wiki/Aliquot_sum) of a number
*
* \details
* The Aliquot sum s(n) of a non-negative integer n is the sum of all
* proper divisors of n, that is, all the divisors of n, other than itself.
* For example, the Aliquot sum of 18 = 1 + 2 + 3 + 6 + 9 = 21
*
* @author [SpiderMath](https://github.com/SpiderMath)
*/
#include <cassert> /// for assert
#include <iostream> /// for IO operations
/**
* @brief Mathematical algorithms
* @namespace math
*/
namespace math {
/**
* Function to return the aliquot sum of a number
* @param num The input number
*/
uint64_t aliquot_sum(const uint64_t num) {
if (num == 0 || num == 1) {
return 0; // The aliquot sum for 0 and 1 is 0
}
uint64_t sum = 0;
for (uint64_t i = 1; i <= num / 2; i++) {
if (num % i == 0) {
sum += i;
}
}
return sum;
}
} // namespace math
/**
* @brief Self-test implementations
* @returns void
*/
static void test() {
// Aliquot sum of 10 is 1 + 2 + 5 = 8
assert(math::aliquot_sum(10) == 8);
// Aliquot sum of 15 is 1 + 3 + 5 = 9
assert(math::aliquot_sum(15) == 9);
// Aliquot sum of 1 is 0
assert(math::aliquot_sum(1) == 0);
// Aliquot sum of 97 is 1 (the aliquot sum of a prime number is 1)
assert(math::aliquot_sum(97) == 1);
std::cout << "All the tests have successfully passed!\n";
}
/**
* @brief Main function
* @returns 0 on exit
*/
int main() {
test(); // run the self-test implementations
return 0;
}