Merge pull request ByteByteGoHq#20 from ongshunping/cpp-solutions-binary-search

Add C++ solutions for Chapter 6 (Binary Search)

Author: Destiny-02

cpp/Binary Search/cutting_wood.cpp

@@ -0,0 +1,30 @@
+#include <vector>
+#include <algorithm>
+
+int cuttingWood(std::vector<int>& heights, int k) {
+    int left = 0;
+    int right = *std::max_element(heights.begin(), heights.end());
+    while (left < right) {
+        // Bias the midpoint to the right during the upper-bound binary 
+        // search.
+        int mid = (left + right) / 2 + 1;
+        if (cutsEnoughWood(mid, k, heights)) {
+            left = mid;
+        } else {
+            right = mid - 1;
+        }
+    }
+    return right;
+}
+
+// Determine if the current value of 'H' cuts at least 'k' meters of 
+// wood.
+bool cutsEnoughWood(int H, int k, std::vector<int>& heights) {
+    int woodCollected = 0;
+    for (int height : heights) {
+        if (height > H) {
+            woodCollected += (height - H);
+        }
+    }
+    return woodCollected >= k;
+}

cpp/Binary Search/find_the_insertion_index.cpp

@@ -0,0 +1,20 @@
+#include <vector>
+
+int findTheInsertionIndex(std::vector<int>& nums, int target) {
+    int left = 0;
+    int right = nums.size();
+    while (left < right) {
+        int mid = (left + right) / 2;
+        // If the midpoint value is greater than or equal to the target,
+        // the lower bound is either at the midpoint, or to its left.
+        if (nums[mid] >= target) {
+            right = mid;
+        }
+        // The midpoint value is less than the target, indicating the
+        // lower bound is somewhere to the right.
+        else {
+            left = mid + 1;
+        }
+    }
+    return left;
+}

cpp/Binary Search/find_the_median_from_two_sorted_arrays.cpp

@@ -0,0 +1,48 @@
+#include <vector>
+#include <algorithm>
+#include <limits>
+#include <cmath>
+
+double findTheMedianFromTwoSortedArrays(std::vector<int>& nums1, std::vector<int>& nums2) {
+    // Optimization: ensure 'nums1' is the smaller array.
+    if (nums2.size() < nums1.size()) {
+        std::swap(nums1, nums2);
+    }
+    int m = nums1.size();
+    int n = nums2.size();
+    int halfTotalLen = (m + n) / 2;
+    int left = 0;
+    int right = m - 1;
+    // A median always exists in a non-empty array, so continue binary search until
+    // it’s found. 
+    while (true) {
+        // Use std::floor with floating-point division to ensure correct rounding down
+        // when left + right is negative, avoiding issues with integer division.
+        int L1Index = std::floor((left + right) / 2.0);
+        int L2Index = halfTotalLen - (L1Index + 1) - 1;
+        // Set to -infinity or +infinity if out of bounds.
+        double L1 = (L1Index < 0) ? -std::numeric_limits<double>::infinity() : nums1[L1Index];
+        double R1 = (L1Index >= m - 1) ? std::numeric_limits<double>::infinity() : nums1[L1Index + 1];
+        double L2 = (L2Index < 0) ? -std::numeric_limits<double>::infinity() : nums2[L2Index];
+        double R2 = (L2Index >= n - 1) ? std::numeric_limits<double>::infinity() : nums2[L2Index + 1];
+        // If 'L1 > R2', then 'L1' is too far to the right. Narrow the search space
+        // toward the left.
+        if (L1 > R2) {
+            right = L1Index - 1;
+        }
+        // If 'L2 > R1', then 'L1' is too far to the left. Narrow the search space
+        // toward the right.
+        else if (L2 > R1) {
+            left = L1Index + 1;
+        }
+        // If both 'L1' and 'L2' are less than or equal to both 'R1' and 'R2', we 
+        // found the correct slice.
+        else {
+            if ((m + n) % 2 == 0) {
+                return (std::max(L1, L2) + std::min(R1, R2)) / 2.0;
+            } else {
+                return std::min(R1, R2);
+            }
+        }
+    }
+}

cpp/Binary Search/find_the_target_in_a_rotated_sorted_array.cpp

@@ -0,0 +1,34 @@
+#include <vector>
+
+int findTheTargetInARotatedSortedArray(std::vector<int>& nums, int target) {
+    int left = 0, right = nums.size() - 1;
+    while (left < right) {
+        int mid = (left + right) / 2;
+        if (nums[mid] == target) {
+            return mid;
+        }
+        // If the left subarray [left : mid] is sorted, check if the
+        // target falls in this range. If it does, search the left
+        // subarray. Otherwise, search the right.
+        else if (nums[left] <= nums[mid]) {
+            if (nums[left] <= target && target < nums[mid]) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        // If the right subarray [mid : right] is sorted, check if the
+        // target falls in this range. If it does, search the right
+        // subarray. Otherwise, search the left.
+        else {
+            if (nums[mid] < target && target <= nums[right]) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+    }
+    // If the target is found in the array, return its index. Otherwise,
+    // return -1.
+    return nums[left] == target ? left : -1;
+}

cpp/Binary Search/first_and_last_occurrences_of_a_number.cpp

@@ -0,0 +1,42 @@
+#include <vector>
+
+std::vector<int> firstAndLastOccurrencesOfANumber(std::vector<int>& nums, int target) {
+    int lowerBound = lowerBoundBinarySearch(nums, target);
+    int upperBound = upperBoundBinarySearch(nums, target);
+    return {lowerBound, upperBound};
+}
+
+int lowerBoundBinarySearch(std::vector<int>& nums, int target) {
+    int left = 0, right = nums.size() - 1;
+    while (left < right) {
+        int mid = (left + right) / 2;
+        if (nums[mid] > target) {
+            right = mid - 1;
+        } else if (nums[mid] < target) {
+            left = mid + 1;
+        } else {
+            right = mid;
+        }
+    }
+    return !nums.empty() && nums[left] == target ? left : -1;
+}
+
+int upperBoundBinarySearch(std::vector<int>& nums, int target) {
+    int left = 0, right = nums.size() - 1;
+    while (left < right) {
+        // In upper-bound binary search, bias the midpoint to the right.
+        int mid = (left + right) / 2 + 1;
+        if (nums[mid] > target) {
+            right = mid - 1;
+        } else if (nums[mid] < target) {
+            left = mid + 1;
+        } else {
+            left = mid;
+        }
+    }
+    // If the target doesn't exist in the array, then it's possible that
+    // 'left = mid + 1' places the left pointer outside the array when
+    // 'mid == n - 1'. So, we use the right pointer in the return 
+    // statement instead.
+    return !nums.empty() && nums[right] == target ? right : -1;
+}

cpp/Binary Search/local_maxima_in_array.cpp

@@ -0,0 +1,14 @@
+#include <vector>
+
+int localMaximaInArray(std::vector<int>& nums) {
+    int left = 0, right = nums.size() - 1;
+    while (left < right) {
+        int mid = (left + right) / 2;
+        if (nums[mid] > nums[mid + 1]) {
+            right = mid;
+        } else {
+            left = mid + 1;
+        }
+    }
+    return left;
+}

cpp/Binary Search/matrix_search.cpp

@@ -0,0 +1,20 @@
+#include <vector>
+
+bool matrixSearch(std::vector<std::vector<int>>& matrix, int target) {
+    int m = matrix.size(), n = matrix[0].size();
+    int left = 0, right = m * n - 1;
+    // Perform binary search to find the target.
+    while (left <= right) {
+        int mid = (left + right) / 2;
+        int r = mid / n;
+        int c = mid % n;
+        if (matrix[r][c] == target) {
+            return true;
+        } else if (matrix[r][c] > target) {
+            right = mid - 1;
+        } else {
+            left = mid + 1;
+        }
+    }
+    return false;
+}

cpp/Binary Search/weighted_random_selection.cpp

@@ -0,0 +1,37 @@
+#include <vector>
+#include <random> 
+
+class WeightedRandomSelection {
+public:
+    std::vector<int> prefixSums;
+    int totalWeight;
+    std::mt19937 rng;
+    std::uniform_int_distribution<int> dist;
+    WeightedRandomSelection(std::vector<int>& weights) : rng(std::random_device{}()) {
+        prefixSums.resize(weights.size());
+        prefixSums[0] = weights[0];
+        for (int i = 1; i < weights.size(); i++) {
+            prefixSums[i] = prefixSums[i - 1] + weights[i];
+        }
+        totalWeight = prefixSums.back();
+        dist = std::uniform_int_distribution<int>(1, totalWeight);
+    }
+    
+    int select() {
+        // Pick a random target between 1 and the largest endpoint on the number 
+        // line.
+        int target = dist(rng);
+        int left = 0, right = prefixSums.size() - 1;
+        // Perform lower-bound binary search to find which endpoint (i.e., prefix 
+        // sum value) corresponds to the target. 
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (prefixSums[mid] < target) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+};