Summing intervals - algorithm

Question

I have to sum intervals like these:
1..6
2..4
The result is 1..6, so there are 6 numbers in the end.
Here's another example:
4..6
8..10
14..16
4, 5, 6, 8, 9, 10, 14, 15, 16, the size is 9.
Now, I have to do this in O(N). Here's a not-so-good approach I quickly came up with using the STL:
#include <set>
#include <stdio.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
set<int> numbers;
int a, b;
for (int i = 0; i < n; i++) {
scanf("%d %d", &a, &b);
for (int u = a; u <= b; u++) {
numbers.insert(u);
}
}
printf("%d\n", numbers.size());
return 0;
}
Any idea of how this can be done in O(N)? I know I have to sort it before, but I can use this I just made:
bool compare(const vector<int> first, const vector<int> second) {
if (first[0] == second[0]) return first[1] < second[1];
return first[0] < second[0];
}
sort(intervals.begin(), intervals.end(), compare);
So it'd be O(log N + N).
Any ideas? Thank you.

Answer 1

If n is the number of intervals then I don't think that there is a way to do this that is not O(n log(n)).
But if we're willing to face that, the first step is to sort the intervals by their left-hand value. (This takes time O(n log(n)).) Then you try to compute a minimal set of intervals in the union according to the following pseudo-code
answer = 0
while intervals left
(min, max) = next interval
while intervals left and min of next interval < max:
if max < max of next interval:
max = max of next interval
move forward in interval list
# the next interval is [min..max]
answer += max - min + 1
(This code is linear in the number of intervals, the non-linear piece is sorting it.)

Answer 2

I did it time ago in OCaml, here's the code:
let rec calc c l1 l2 =
match c,l1,l2 with
None, (f1,t1) :: y1, ((f2,t2) :: y2 as n2) when f1 < f2 -> calc (Some (f1,t1)) y1 n2
| None, n1, (f2,t2) :: y2 -> calc (Some (f2,t2)) n1 y2
| None, _, _ -> []
| (Some (fc,tc) as cur), (f1,t1) :: y1, ((f2,t2) :: y2 as n2) when t1 <= fc -> calc cur y1 n2
| (Some (fc,tc) as cur), ((f1,t1) :: y1 as n1), (f2,t2) :: y2 when t2 <= fc -> calc cur n1 y2
| Some (fc,tc), (f1,t1) :: y1, ((f2,t2) :: y2 as n2) when f1 <= tc && t1 > fc -> calc (Some (fc,t1)) y1 n2
| Some (fc,tc), ((f1,t1) :: y1 as n1), (f2,t2) :: y2 when f2 <= tc && t2 > fc -> calc (Some (fc,t2)) n1 y2
| Some (fc,tc), (f1,t1) :: y1, ((f2,t2) :: y2 as n2) when f1 < f2 -> [fc,tc] # calc (Some (f1,t1)) y1 n2
| Some (fc,tc), (t :: e as n1), (f2,t2) :: y2 -> [fc,tc] # calc (Some (f2,t2)) n1 y2
| Some (fc,tc), [], (f,t) :: tr when f <= tc && t > tc -> calc (Some (fc,t)) [] tr
| Some (fc,tc), [], (f,t) :: tr when f <= tc && t <= tc -> calc (Some (fc,tc)) [] tr
| Some (fc,tc), [], x -> [fc,tc] # x
| Some (fc,tc), (f,t) :: tr, [] when f <= tc && t > tc -> calc (Some (fc,t)) tr []
| Some (fc,tc), (f,t) :: tr, [] when f <= tc && t <= tc -> calc (Some (fc,tc)) tr []
| Some (fc,tc), x, [] -> [fc,tc] # x
This computes the union of two ranges (which are two arbitrary sets of couple of elements) and it's O(N+M) (N and M are the number of single intervals in each set). Result is sorted.
After this you can easily compute the list in linear time:
List.fold_left (fun a (f,t) -> for i = f to t do a := !a # [Int i] done; a) (ref []) range
Ok, this is OCaml but I had it ready so maybe it will be useful to you, especially on tricky part that merges intervals by deleting overlapping parts, since I spent some time to figure out the algorithm but I couldn't describe it to you in metacode (as you can see from implementation).

Answer 3

I believe the best complexity you can achieve here is O(N*log(N)) where N is the number of intervals. The solution is not very hard - you need to first sort the intervals by their beginning and then do another linear pass to compute their union. I will try to write some code in c++:
struct Interval {
int from, to;
bool operator<(const Interval& other) const {
if(from != other.from) {
return from < other.from;
}
return to < other.to;
}
};
int main() {
vector<Interval> intervals;
sort(intervals.begin(), intervals.end());
int current_position = intervals[0].from;
int sum = 0;
for (int i = 0; i < intervals.size(); ++i) {
if (intervals[i].to < current_position) {
continue;
} else if (intervals[i].from <= current_position) {
sum += intervals[i].to - current_position + 1;
current_position = intervals[i].to + 1;
} else {
sum += intervals[i].to - intervals[i].from + 1;
current_position = intervals[i].to + 1;
}
}
std::cout << sum << std::endl;
return 0;
}

Answer 4

First, let's be clear about what N is - is it the number of segments?
If this is the case, then you can't always do it - simply printing out the number of individual numbers within all the segments - call that m - takes O(m) time. The fastest algorithm, then, can't be better than O(m+n)