backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-02-03 02:25:57 +08:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into directory-update

Browse Source
This commit is contained in:
realstealthninja
2024-11-02 20:02:23 +05:30
committed by GitHub
parent 7d9f6b30da 85d62bb80d
commit d0663990db
3 changed files with 398 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
dynamic_programming/Unbounded_0_1_Knapsack.cpp Normal file
View File

@@ -0,0 +1,151 @@
/**
* @file
* @brief Implementation of the Unbounded 0/1 Knapsack Problem
*
* @details
* The Unbounded 0/1 Knapsack problem allows taking unlimited quantities of each item.
* The goal is to maximize the total value without exceeding the given knapsack capacity.
* Unlike the 0/1 knapsack, where each item can be taken only once, in this variation,
* any item can be picked any number of times as long as the total weight stays within
* the knapsack's capacity.
*
* Given a set of N items, each with a weight and a value, represented by the arrays
* `wt` and `val` respectively, and a knapsack with a weight limit W, the task is to
* fill the knapsack to maximize the total value.
*
* @note weight and value of items is greater than zero
*
* ### Algorithm
* The approach uses dynamic programming to build a solution iteratively.
* A 2D array is used for memoization to store intermediate results, allowing
* the function to avoid redundant calculations.
*
* @author [Sanskruti Yeole](https://github.com/yeolesanskruti)
* @see dynamic_programming/0_1_knapsack.cpp
*/
#include <iostream> // Standard input-output stream
#include <vector> // Standard library for using dynamic arrays (vectors)
#include <cassert> // For using assert function to validate test cases
#include <cstdint> // For fixed-width integer types like std::uint16_t
/**
* @namespace dynamic_programming
* @brief Namespace for dynamic programming algorithms
*/
namespace dynamic_programming {
/**
* @namespace Knapsack
* @brief Implementation of unbounded 0-1 knapsack problem
*/
namespace unbounded_knapsack {
/**
* @brief Recursive function to calculate the maximum value obtainable using
* an unbounded knapsack approach.
*
* @param i Current index in the value and weight vectors.
* @param W Remaining capacity of the knapsack.
* @param val Vector of values corresponding to the items.
* @note "val" data type can be changed according to the size of the input.
* @param wt Vector of weights corresponding to the items.
* @note "wt" data type can be changed according to the size of the input.
* @param dp 2D vector for memoization to avoid redundant calculations.
* @return The maximum value that can be obtained for the given index and capacity.
*/
std::uint16_t KnapSackFilling(std::uint16_t i, std::uint16_t W,
const std::vector<std::uint16_t>& val,
const std::vector<std::uint16_t>& wt,
std::vector<std::vector<int>>& dp) {
if (i == 0) {
if (wt[0] <= W) {
return (W / wt[0]) * val[0]; // Take as many of the first item as possible
} else {
return 0; // Can't take the first item
}
}
if (dp[i][W] != -1) return dp[i][W]; // Return result if available
int nottake = KnapSackFilling(i - 1, W, val, wt, dp); // Value without taking item i
int take = 0;
if (W >= wt[i]) {
take = val[i] + KnapSackFilling(i, W - wt[i], val, wt, dp); // Value taking item i
}
return dp[i][W] = std::max(take, nottake); // Store and return the maximum value
}
/**
* @brief Wrapper function to initiate the unbounded knapsack calculation.
*
* @param N Number of items.
* @param W Maximum weight capacity of the knapsack.
* @param val Vector of values corresponding to the items.
* @param wt Vector of weights corresponding to the items.
* @return The maximum value that can be obtained for the given capacity.
*/
std::uint16_t unboundedKnapsack(std::uint16_t N, std::uint16_t W,
const std::vector<std::uint16_t>& val,
const std::vector<std::uint16_t>& wt) {
if(N==0)return 0; // Expect 0 since no items
std::vector<std::vector<int>> dp(N, std::vector<int>(W + 1, -1)); // Initialize memoization table
return KnapSackFilling(N - 1, W, val, wt, dp); // Start the calculation
}
} // unbounded_knapsack
} // dynamic_programming
/**
* @brief self test implementation
* @return void
*/
static void tests() {
// Test Case 1
std::uint16_t N1 = 4; // Number of items
std::vector<std::uint16_t> wt1 = {1, 3, 4, 5}; // Weights of the items
std::vector<std::uint16_t> val1 = {6, 1, 7, 7}; // Values of the items
std::uint16_t W1 = 8; // Maximum capacity of the knapsack
// Test the function and assert the expected output
assert(unboundedKnapsack(N1, W1, val1, wt1) == 48);
std::cout << "Maximum Knapsack value " << unboundedKnapsack(N1, W1, val1, wt1) << std::endl;
// Test Case 2
std::uint16_t N2 = 3; // Number of items
std::vector<std::uint16_t> wt2 = {10, 20, 30}; // Weights of the items
std::vector<std::uint16_t> val2 = {60, 100, 120}; // Values of the items
std::uint16_t W2 = 5; // Maximum capacity of the knapsack
// Test the function and assert the expected output
assert(unboundedKnapsack(N2, W2, val2, wt2) == 0);
std::cout << "Maximum Knapsack value " << unboundedKnapsack(N2, W2, val2, wt2) << std::endl;
// Test Case 3
std::uint16_t N3 = 3; // Number of items
std::vector<std::uint16_t> wt3 = {2, 4, 6}; // Weights of the items
std::vector<std::uint16_t> val3 = {5, 11, 13};// Values of the items
std::uint16_t W3 = 27;// Maximum capacity of the knapsack
// Test the function and assert the expected output
assert(unboundedKnapsack(N3, W3, val3, wt3) == 27);
std::cout << "Maximum Knapsack value " << unboundedKnapsack(N3, W3, val3, wt3) << std::endl;
// Test Case 4
std::uint16_t N4 = 0; // Number of items
std::vector<std::uint16_t> wt4 = {}; // Weights of the items
std::vector<std::uint16_t> val4 = {}; // Values of the items
std::uint16_t W4 = 10; // Maximum capacity of the knapsack
assert(unboundedKnapsack(N4, W4, val4, wt4) == 0);
std::cout << "Maximum Knapsack value for empty arrays: " << unboundedKnapsack(N4, W4, val4, wt4) << std::endl;
std::cout << "All test cases passed!" << std::endl;
}
/**
* @brief main function
* @return 0 on successful exit
*/
int main() {
tests(); // Run self test implementation
return 0;
}

211
graph/topological_sort.cpp
View File

@@ -1,50 +1,189 @@
#include <algorithm>
#include <iostream>
#include <vector>
/**
* @file
* @brief [Topological Sort
* Algorithm](https://en.wikipedia.org/wiki/Topological_sorting)
* @details
* Topological sorting of a directed graph is a linear ordering or its vertices
* such that for every directed edge (u,v) from vertex u to vertex v, u comes
* before v in the oredering.
*
* A topological sort is possible only in a directed acyclic graph (DAG).
* This file contains code of finding topological sort using Kahn's Algorithm
* which involves using Depth First Search technique
*/
int number_of_vertices,
number_of_edges; // For number of Vertices (V) and number of edges (E)
std::vector<std::vector<int>> graph;
std::vector<bool> visited;
std::vector<int> topological_order;
#include <algorithm> // For std::reverse
#include <cassert> // For assert
#include <iostream> // For IO operations
#include <stack> // For std::stack
#include <stdexcept> // For std::invalid_argument
#include <vector> // For std::vector
void dfs(int v) {
visited[v] = true;
for (int u : graph[v]) {
if (!visited[u]) {
dfs(u);
/**
* @namespace graph
* @brief Graph algorithms
*/
namespace graph {
/**
* @namespace topological_sort
* @brief Topological Sort Algorithm
*/
namespace topological_sort {
/**
* @class Graph
* @brief Class that represents a directed graph and provides methods for
* manipulating the graph
*/
class Graph {
private:
int n; // Number of nodes
std::vector<std::vector<int>> adj; // Adjacency list representation
public:
/**
* @brief Constructor for the Graph class
* @param nodes Number of nodes in the graph
*/
Graph(int nodes) : n(nodes), adj(nodes) {}
/**
* @brief Function that adds an edge between two nodes or vertices of graph
* @param u Start node of the edge
* @param v End node of the edge
*/
void addEdge(int u, int v) { adj[u].push_back(v); }
/**
* @brief Get the adjacency list of the graph
* @returns A reference to the adjacency list
*/
const std::vector<std::vector<int>>& getAdjacencyList() const {
return adj;
}
/**
* @brief Get the number of nodes in the graph
* @returns The number of nodes
*/
int getNumNodes() const { return n; }
};
/**
* @brief Function to perform Depth First Search on the graph
* @param v Starting vertex for depth-first search
* @param visited Array representing whether each node has been visited
* @param graph Adjacency list of the graph
* @param s Stack containing the vertices for topological sorting
*/
void dfs(int v, std::vector<int>& visited,
const std::vector<std::vector<int>>& graph, std::stack<int>& s) {
visited[v] = 1;
for (int neighbour : graph[v]) {
if (!visited[neighbour]) {
dfs(neighbour, visited, graph, s);
}
}
topological_order.push_back(v);
s.push(v);
}
void topological_sort() {
visited.assign(number_of_vertices, false);
topological_order.clear();
for (int i = 0; i < number_of_vertices; ++i) {
/**
* @brief Function to get the topological sort of the graph
* @param g Graph object
* @returns A vector containing the topological order of nodes
*/
std::vector<int> topologicalSort(const Graph& g) {
int n = g.getNumNodes();
const auto& adj = g.getAdjacencyList();
std::vector<int> visited(n, 0);
std::stack<int> s;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
dfs(i);
dfs(i, visited, adj, s);
}
}
reverse(topological_order.begin(), topological_order.end());
}
int main() {
std::cout
<< "Enter the number of vertices and the number of directed edges\n";
std::cin >> number_of_vertices >> number_of_edges;
int x = 0, y = 0;
graph.resize(number_of_vertices, std::vector<int>());
for (int i = 0; i < number_of_edges; ++i) {
std::cin >> x >> y;
x--, y--; // to convert 1-indexed to 0-indexed
graph[x].push_back(y);
std::vector<int> ans;
while (!s.empty()) {
int elem = s.top();
s.pop();
ans.push_back(elem);
}
topological_sort();
std::cout << "Topological Order : \n";
for (int v : topological_order) {
std::cout << v + 1
<< ' '; // converting zero based indexing back to one based.
if (ans.size() < n) { // Cycle detected
throw std::invalid_argument("cycle detected in graph");
}
return ans;
}
} // namespace topological_sort
} // namespace graph
/**
* @brief Self-test implementation
* @returns void
*/
static void test() {
// Test 1
std::cout << "Testing for graph 1\n";
int n_1 = 6;
graph::topological_sort::Graph graph1(n_1);
graph1.addEdge(4, 0);
graph1.addEdge(5, 0);
graph1.addEdge(5, 2);
graph1.addEdge(2, 3);
graph1.addEdge(3, 1);
graph1.addEdge(4, 1);
std::vector<int> ans_1 = graph::topological_sort::topologicalSort(graph1);
std::vector<int> expected_1 = {5, 4, 2, 3, 1, 0};
std::cout << "Topological Sorting Order: ";
for (int i : ans_1) {
std::cout << i << " ";
}
std::cout << '\n';
assert(ans_1 == expected_1);
std::cout << "Test Passed\n\n";
// Test 2
std::cout << "Testing for graph 2\n";
int n_2 = 5;
graph::topological_sort::Graph graph2(n_2);
graph2.addEdge(0, 1);
graph2.addEdge(0, 2);
graph2.addEdge(1, 2);
graph2.addEdge(2, 3);
graph2.addEdge(1, 3);
graph2.addEdge(2, 4);
std::vector<int> ans_2 = graph::topological_sort::topologicalSort(graph2);
std::vector<int> expected_2 = {0, 1, 2, 4, 3};
std::cout << "Topological Sorting Order: ";
for (int i : ans_2) {
std::cout << i << " ";
}
std::cout << '\n';
assert(ans_2 == expected_2);
std::cout << "Test Passed\n\n";
// Test 3 - Graph with cycle
std::cout << "Testing for graph 3\n";
int n_3 = 3;
graph::topological_sort::Graph graph3(n_3);
graph3.addEdge(0, 1);
graph3.addEdge(1, 2);
graph3.addEdge(2, 0);
try {
graph::topological_sort::topologicalSort(graph3);
} catch (std::invalid_argument& err) {
assert(std::string(err.what()) == "cycle detected in graph");
}
std::cout << "Test Passed\n";
}
/**
* @brief Main function
* @returns 0 on exit
*/
int main() {
test(); // run self test implementations
return 0;
}

94
math/sieve_of_eratosthenes.cpp
View File

@@ -1,6 +1,7 @@
/**
* @file
* @brief Get list of prime numbers using Sieve of Eratosthenes
* @brief Prime Numbers using [Sieve of
* Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes)
* @details
* Sieve of Eratosthenes is an algorithm that finds all the primes
* between 2 and N.
@@ -11,21 +12,39 @@
* @see primes_up_to_billion.cpp prime_numbers.cpp
*/
#include <cassert>
#include <iostream>
#include <vector>
#include <cassert> /// for assert
#include <iostream> /// for IO operations
#include <vector> /// for std::vector
/**
* This is the function that finds the primes and eliminates the multiples.
* @namespace math
* @brief Mathematical algorithms
*/
namespace math {
/**
* @namespace sieve_of_eratosthenes
* @brief Functions for finding Prime Numbers using Sieve of Eratosthenes
*/
namespace sieve_of_eratosthenes {
/**
* @brief Function to sieve out the primes
* @details
* This function finds all the primes between 2 and N using the Sieve of
* Eratosthenes algorithm. It starts by assuming all numbers (except zero and
* one) are prime and then iteratively marks the multiples of each prime as
* non-prime.
*
* Contains a common optimization to start eliminating multiples of
* a prime p starting from p * p since all of the lower multiples
* have been already eliminated.
* @param N number of primes to check
* @return is_prime a vector of `N + 1` booleans identifying if `i`^th number is a prime or not
* @param N number till which primes are to be found
* @return is_prime a vector of `N + 1` booleans identifying if `i`^th number is
* a prime or not
*/
std::vector<bool> sieve(uint32_t N) {
std::vector<bool> is_prime(N + 1, true);
is_prime[0] = is_prime[1] = false;
std::vector<bool> is_prime(N + 1, true); // Initialize all as prime numbers
is_prime[0] = is_prime[1] = false; // 0 and 1 are not prime numbers
for (uint32_t i = 2; i * i <= N; i++) {
if (is_prime[i]) {
for (uint32_t j = i * i; j <= N; j += i) {
@@ -37,9 +56,10 @@ std::vector<bool> sieve(uint32_t N) {
}
/**
* This function prints out the primes to STDOUT
* @param N number of primes to check
* @param is_prime a vector of `N + 1` booleans identifying if `i`^th number is a prime or not
* @brief Function to print the prime numbers
* @param N number till which primes are to be found
* @param is_prime a vector of `N + 1` booleans identifying if `i`^th number is
* a prime or not
*/
void print(uint32_t N, const std::vector<bool> &is_prime) {
for (uint32_t i = 2; i <= N; i++) {
@@ -50,23 +70,53 @@ void print(uint32_t N, const std::vector<bool> &is_prime) {
std::cout << std::endl;
}
} // namespace sieve_of_eratosthenes
} // namespace math
/**
* Test implementations
* @brief Self-test implementations
* @return void
*/
void tests() {
// 0 1 2 3 4 5 6 7 8 9 10
std::vector<bool> ans{false, false, true, true, false, true, false, true, false, false, false};
assert(sieve(10) == ans);
static void tests() {
std::vector<bool> is_prime_1 =
math::sieve_of_eratosthenes::sieve(static_cast<uint32_t>(10));
std::vector<bool> is_prime_2 =
math::sieve_of_eratosthenes::sieve(static_cast<uint32_t>(20));
std::vector<bool> is_prime_3 =
math::sieve_of_eratosthenes::sieve(static_cast<uint32_t>(100));
std::vector<bool> expected_1{false, false, true, true, false, true,
false, true, false, false, false};
assert(is_prime_1 == expected_1);
std::vector<bool> expected_2{false, false, true, true, false, true,
false, true, false, false, false, true,
false, true, false, false, false, true,
false, true, false};
assert(is_prime_2 == expected_2);
std::vector<bool> expected_3{
false, false, true, true, false, true, false, true, false, false,
false, true, false, true, false, false, false, true, false, true,
false, false, false, true, false, false, false, false, false, true,
false, true, false, false, false, false, false, true, false, false,
false, true, false, true, false, false, false, true, false, false,
false, false, false, true, false, false, false, false, false, true,
false, true, false, false, false, false, false, true, false, false,
false, true, false, true, false, false, false, false, false, true,
false, false, false, true, false, false, false, false, false, true,
false, false, false, false, false, false, false, true, false, false,
false};
assert(is_prime_3 == expected_3);
std::cout << "All tests have passed successfully!\n";
}
/**
* Main function
* @brief Main function
* @returns 0 on exit
*/
int main() {
tests();
uint32_t N = 100;
std::vector<bool> is_prime = sieve(N);
print(N, is_prime);
return 0;
}