Merge branch 'master' into patch-1

Author: dev-priyanshu15

DIRECTORY.md

@@ -325,6 +325,7 @@
   * [Addition Rule](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/addition_rule.cpp)
   * [Bayes Theorem](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/bayes_theorem.cpp)
   * [Binomial Dist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/binomial_dist.cpp)
+  * [Exponential Dist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/exponential_dist.cpp)
   * [Geometric Dist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/geometric_dist.cpp)
   * [Poisson Dist](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/poisson_dist.cpp)
   * [Windowed Median](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/probability/windowed_median.cpp)
@@ -339,6 +340,7 @@
   * [Sparse Table](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/range_queries/sparse_table.cpp)
 
 ## Search
+  * [Longest Increasing Subsequence Using Binary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/search/Longest_Increasing_Subsequence_using_binary_search.cpp)
   * [Binary Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/search/binary_search.cpp)
   * [Exponential Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/search/exponential_search.cpp)
   * [Fibonacci Search](https://github.com/TheAlgorithms/C-Plus-Plus/blob/HEAD/search/fibonacci_search.cpp)

probability/exponential_dist.cpp

@@ -0,0 +1,151 @@
+/**
+ * @file
+ * @brief [Exponential
+ * Distribution](https://en.wikipedia.org/wiki/Exponential_distribution)
+ *
+ * The exponential distribution is used to model
+ * events occuring between a Poisson process like radioactive decay.
+ *
+ * \f[P(x, \lambda) = \lambda e^{-\lambda x}\f]
+ *
+ * Summary of variables used:
+ * \f$\lambda\f$ : rate parameter
+ */
+
+#include <cassert>    // For assert
+#include <cmath>      // For std::pow
+#include <iostream>   // For I/O operation
+#include <stdexcept>  // For std::invalid_argument
+#include <string>     // For std::string
+
+/**
+ * @namespace probability
+ * @brief Probability algorithms
+ */
+namespace probability {
+/**
+ * @namespace exponential_dist
+ * @brief Functions for the [Exponential
+ * Distribution](https://en.wikipedia.org/wiki/Exponential_distribution)
+ * algorithm implementation
+ */
+namespace geometric_dist {
+/**
+ * @brief the expected value of the exponential distribution
+ * @returns \f[\mu = \frac{1}{\lambda}\f]
+ */
+double exponential_expected(double lambda) {
+    if (lambda <= 0) {
+        throw std::invalid_argument("lambda must be greater than 0");
+    }
+    return 1 / lambda;
+}
+
+/**
+ * @brief the variance of the exponential distribution
+ * @returns \f[\sigma^2 = \frac{1}{\lambda^2}\f]
+ */
+double exponential_var(double lambda) {
+    if (lambda <= 0) {
+        throw std::invalid_argument("lambda must be greater than 0");
+    }
+    return 1 / pow(lambda, 2);
+}
+
+/**
+ * @brief the standard deviation of the exponential distribution
+ * @returns \f[\sigma = \frac{1}{\lambda}\f]
+ */
+double exponential_std(double lambda) {
+    if (lambda <= 0) {
+        throw std::invalid_argument("lambda must be greater than 0");
+    }
+    return 1 / lambda;
+}
+}  // namespace geometric_dist
+}  // namespace probability
+
+/**
+ * @brief Self-test implementations
+ * @returns void
+ */
+static void test() {
+    double lambda_1 = 1;
+    double expected_1 = 1;
+    double var_1 = 1;
+    double std_1 = 1;
+
+    double lambda_2 = 2;
+    double expected_2 = 0.5;
+    double var_2 = 0.25;
+    double std_2 = 0.5;
+
+    double lambda_3 = 3;
+    double expected_3 = 0.333333;
+    double var_3 = 0.111111;
+    double std_3 = 0.333333;
+
+    double lambda_4 = 0;     // Test 0
+    double lambda_5 = -2.3;  // Test negative value
+
+    const float threshold = 1e-3f;
+
+    std::cout << "Test for lambda = 1 \n";
+    assert(
+        std::abs(expected_1 - probability::geometric_dist::exponential_expected(
+                                  lambda_1)) < threshold);
+    assert(std::abs(var_1 - probability::geometric_dist::exponential_var(
+                                lambda_1)) < threshold);
+    assert(std::abs(std_1 - probability::geometric_dist::exponential_std(
+                                lambda_1)) < threshold);
+    std::cout << "ALL TEST PASSED\n\n";
+
+    std::cout << "Test for lambda = 2 \n";
+    assert(
+        std::abs(expected_2 - probability::geometric_dist::exponential_expected(
+                                  lambda_2)) < threshold);
+    assert(std::abs(var_2 - probability::geometric_dist::exponential_var(
+                                lambda_2)) < threshold);
+    assert(std::abs(std_2 - probability::geometric_dist::exponential_std(
+                                lambda_2)) < threshold);
+    std::cout << "ALL TEST PASSED\n\n";
+
+    std::cout << "Test for lambda = 3 \n";
+    assert(
+        std::abs(expected_3 - probability::geometric_dist::exponential_expected(
+                                  lambda_3)) < threshold);
+    assert(std::abs(var_3 - probability::geometric_dist::exponential_var(
+                                lambda_3)) < threshold);
+    assert(std::abs(std_3 - probability::geometric_dist::exponential_std(
+                                lambda_3)) < threshold);
+    std::cout << "ALL TEST PASSED\n\n";
+
+    std::cout << "Test for lambda = 0 \n";
+    try {
+        probability::geometric_dist::exponential_expected(lambda_4);
+        probability::geometric_dist::exponential_var(lambda_4);
+        probability::geometric_dist::exponential_std(lambda_4);
+    } catch (std::invalid_argument& err) {
+        assert(std::string(err.what()) == "lambda must be greater than 0");
+    }
+    std::cout << "ALL TEST PASSED\n\n";
+
+    std::cout << "Test for lambda = -2.3 \n";
+    try {
+        probability::geometric_dist::exponential_expected(lambda_5);
+        probability::geometric_dist::exponential_var(lambda_5);
+        probability::geometric_dist::exponential_std(lambda_5);
+    } catch (std::invalid_argument& err) {
+        assert(std::string(err.what()) == "lambda must be greater than 0");
+    }
+    std::cout << "ALL TEST PASSED\n\n";
+}
+
+/**
+ * @brief Main function
+ * @return 0 on exit
+ */
+int main() {
+    test();  // Self test implementation
+    return 0;
+}

search/Longest_Increasing_Subsequence_using_binary_search.cpp

@@ -0,0 +1,117 @@
+/**
+ * @file
+ * @brief find the length of the Longest Increasing Subsequence (LIS)
+ * using [Binary Search](https://en.wikipedia.org/wiki/Longest_increasing_subsequence)
+ * @details
+ * Given an integer array nums, return the length of the longest strictly
+ * increasing subsequence.
+ * The longest increasing subsequence is described as a subsequence of an array
+ * where: All elements of the subsequence are in increasing order. This subsequence
+ * itself is of the longest length possible.
+
+ * For solving this problem we have Three Approaches :-
+
+ * Approach 1 :- Using Brute Force
+ * The first approach that came to your mind is the Brute Force approach where we
+ * generate all subsequences and then manually filter the subsequences whose
+ * elements come in increasing order and then return the longest such subsequence.
+ * Time Complexity :- O(2^n)
+ * It's time complexity is exponential. Therefore we will try some other
+ * approaches.
+
+ * Approach 2 :- Using Dynamic Programming
+ * To generate all subsequences we will use recursion and in the recursive logic we
+ * will figure out a way to solve this problem. Recursive Logic to solve this
+ * problem:-
+ * 1. We only consider the element in the subsequence if the element is grater then
+ * the last element present in the subsequence
+ * 2. When we consider the element we will increase the length of subsequence by 1
+ * Time Complexity: O(N*N)
+ * Space Complexity: O(N*N) + O(N)
+
+ * This approach is better then the previous Brute Force approach so, we can
+ * consider this approach.
+
+ * But when the Constraints for the problem is very larger then this approach fails
+
+ * Approach 3 :- Using Binary Search
+ * Other approaches use additional space to create a new subsequence Array.
+ * Instead, this solution uses the existing nums Array to build the subsequence
+ * array. We can do this because the length of the subsequence array will never be
+ * longer than the current index.
+
+ * Time complexity: O(n∗log(n))
+ * Space complexity: O(1)
+
+ * This approach consider Most optimal Approach for solving this problem
+
+ * @author [Naman Jain](https://github.com/namanmodi65)
+ */
+
+#include <cassert>   /// for std::assert
+#include <iostream>  /// for IO operations
+#include <vector>    /// for std::vector
+#include <algorithm> /// for std::lower_bound
+#include <cstdint>   /// for std::uint32_t
+
+/**
+ * @brief Function to find the length of the Longest Increasing Subsequence (LIS)
+ * using Binary Search
+ * @tparam T The type of the elements in the input vector
+ * @param nums The input vector of elements of type T
+ * @return The length of the longest increasing subsequence
+ */
+template <typename T>
+std::uint32_t longest_increasing_subsequence_using_binary_search(std::vector<T>& nums) {
+    if (nums.empty()) return 0;
+
+    std::vector<T> ans;
+    ans.push_back(nums[0]);
+    for (std::size_t i = 1; i < nums.size(); i++) {
+        if (nums[i] > ans.back()) {
+            ans.push_back(nums[i]);
+        } else {
+            auto idx = std::lower_bound(ans.begin(), ans.end(), nums[i]) - ans.begin();
+            ans[idx] = nums[i];
+        }
+    }
+    return static_cast<std::uint32_t>(ans.size());
+}
+
+/**
+ * @brief Test cases for Longest Increasing Subsequence function
+ * @returns void
+ */
+static void tests() {
+    std::vector<int> arr = {10, 9, 2, 5, 3, 7, 101, 18};
+    assert(longest_increasing_subsequence_using_binary_search(arr) == 4);
+
+    std::vector<int> arr2 = {0, 1, 0, 3, 2, 3};
+    assert(longest_increasing_subsequence_using_binary_search(arr2) == 4);
+
+    std::vector<int> arr3 = {7, 7, 7, 7, 7, 7, 7};
+    assert(longest_increasing_subsequence_using_binary_search(arr3) == 1);
+
+    std::vector<int> arr4 = {-10, -1, -5, 0, 5, 1, 2};
+    assert(longest_increasing_subsequence_using_binary_search(arr4) == 5);
+
+    std::vector<double> arr5 = {3.5, 1.2, 2.8, 3.1, 4.0};
+    assert(longest_increasing_subsequence_using_binary_search(arr5) == 4);
+
+    std::vector<char> arr6 = {'a', 'b', 'c', 'a', 'd'};
+    assert(longest_increasing_subsequence_using_binary_search(arr6) == 4);
+
+    std::vector<int> arr7 = {};
+    assert(longest_increasing_subsequence_using_binary_search(arr7) == 0);
+
+    std::cout << "All tests have successfully passed!\n";
+}
+
+/**
+ * @brief Main function to run tests
+ * @returns 0 on exit
+ */
+int main() {
+    tests();  // run self test implementation
+    return 0;
+}