Merge pull request ByteByteGoHq#33 from ongshunping/cpp-solutions-intervals

Destiny-02 · web-flow · commit b6ad7b3cf88a · 2025-01-16T22:25:16.000+11:00
Add C++ solutions for Chapter 9 (Intervals)
diff --git a/cpp/Intervals/identify_all_interval_overlaps.cpp b/cpp/Intervals/identify_all_interval_overlaps.cpp
@@ -0,0 +1,45 @@
+#include <vector>
+#include <algorithm>
+#include "ds/Interval.h"
+using ds::Interval;
+
+/**
+ * Definition of Interval:
+ * struct Interval {
+ *     int start;
+ *     int end;
+ *     Interval(int start, int end) : start(start), end(end) {}
+ * };
+ */
+
+std::vector<Interval> identifyAllIntervalOverlaps(std::vector<Interval>& intervals1, std::vector<Interval>& intervals2) {
+    std::vector<Interval> overlaps;
+    int i = 0;
+    int j = 0;
+    while (i < intervals1.size() && j < intervals2.size()) {
+        // Set A to the interval that starts first and B to the other 
+        // interval.
+        Interval A, B;
+        if (intervals1[i].start <= intervals2[j].start) {
+            A = intervals1[i];
+            B = intervals2[j];
+        } else {
+            A = intervals2[j];
+            B = intervals1[i];
+        }
+        // If there's an overlap, add the overlap. Use `emplace_back`
+        // to construct `Interval` in place, potentially avoiding an
+        // extra copy compared to `push_back`. 
+        if (A.end >= B.start) {
+            overlaps.emplace_back(B.start, std::min(A.end, B.end));
+        }
+        // Advance the pointer associated with the interval that ends 
+        // first.
+        if (intervals1[i].end < intervals2[j].end) {
+            i++;
+        } else {
+            j++;
+        }
+    }
+    return overlaps;
+}
diff --git a/cpp/Intervals/largest_overlap_of_intervals.cpp b/cpp/Intervals/largest_overlap_of_intervals.cpp
@@ -0,0 +1,37 @@
+#include <vector>
+#include <algorithm>
+#include "ds/Interval.h"
+using ds::Interval;
+
+/**
+ * Definition of Interval:
+ * struct Interval {
+ *     int start;
+ *     int end;
+ *     Interval(int start, int end) : start(start), end(end) {}
+ * };
+ */
+
+int largestOverlapOfIntervals(std::vector<Interval>& intervals) {
+    std::vector<std::pair<int, char>> points;
+    for (Interval& interval : intervals) {
+        points.emplace_back(interval.start, 'S'); 
+        points.emplace_back(interval.end, 'E');   
+    }
+    // Sort in chronological order. If multiple points occur at the same time,
+    // ensure end points are prioritized before start points.
+    std::sort(points.begin(), points.end());
+    int activeIntervals = 0;
+    int maxOverlaps = 0;
+    for (auto& p : points) {
+        int time = p.first;
+        char pointType = p.second;
+        if (pointType == 'S') {
+            activeIntervals += 1;
+        } else {
+            activeIntervals -= 1;
+        }
+        maxOverlaps = std::max(maxOverlaps, activeIntervals);
+    }
+    return maxOverlaps;
+}
diff --git a/cpp/Intervals/merge_overlapping_intervals.cpp b/cpp/Intervals/merge_overlapping_intervals.cpp
@@ -0,0 +1,34 @@
+#include <vector>
+#include <algorithm>
+#include "ds/Interval.h"
+using ds::Interval;
+
+/**
+ * Definition of Interval:
+ * struct Interval {
+ *     int start;
+ *     int end;
+ *     Interval(int start, int end) : start(start), end(end) {}
+ * };
+ */
+
+std::vector<Interval> mergeOverlappingIntervals(std::vector<Interval>& intervals) {
+    std::sort(intervals.begin(), intervals.end(), [](Interval& a, Interval& b) {
+        return a.start < b.start;
+    });
+    std::vector<Interval> merged;
+    merged.push_back(intervals[0]);
+    for (int i = 1; i < intervals.size(); i++) {
+        Interval& A = merged.back();
+        Interval& B = intervals[i];
+        // If A and B don't overlap, add B to the merged list.
+        if (A.end < B.start) {
+            merged.push_back(B);
+        }
+        // If they do overlap, merge A with B.
+        else {
+            A.end = std::max(A.end, B.end);
+        }
+    }
+    return merged;
+}
