finding largest subset of intervals - algorithm

Question

I was trying to solve this problem here.
Also, posting the question: You are given a list of N intervals.
The challenge is to select the largest subset of intervals such that no three intervals in the subset share a common point?
but couldn't come around to a solution. This is what I tried so far:
DP: don't think problem has overlapping sub-problems so this didn't work
reduced it to a graph with each point being a vertex and intervals being the edges of the undirected graph. Then problem reduces to finding maximum length disjoint paths in the graph. Couldn't come up with a neat way of doing this as well
tried reducing it to network flow but that didn't work as well.
Could you guys give me hints on how to approach this problem or if I am missing anything. Sorry, I am doing algorithms after a really long time and been out of touch lately.

Answer 1

I'll give the solution in general words without programming it.
Let's denote segments as s1, s2, ..., sn. Their beginnings as b1, b2,... bn, and their ends as e1, e2,... en.
Sort segments by their beginnings, so b1< b2<...< bn. It is enough to check them if the condition of no three segments covering a point holds. We will be doing so in the order from b1 to bn. So, start with b1, move to the next point, and so on one by one, until at some point bi there are three segments covering it. These will be the segment si and two others, let's say sj and sk. Of those three segments delete the one with the maximum end point, i.e. max{ei, ej, ek}. Move on to the beginning of the next segment (bi+1). When we reach bn the process is done. All the segments that are left constitute the largest subset of segments such that no three segments share a common point.
Why this will be the maximal subset. Let's say our solution is S (the set of segments). Suppose there is an optimal solution S*. Again, sort the segments in S and S* by the coordinate of their beginnings. Now, we will be going through the segments in S and in S* and comparing their end points. By the construction of S for any kth segment in S its end coordinate is smaller than the end coordinate of kth segment in S* (ek<=ek). Therefore, the number of segments in S is not less than in S (moving in S* we're always outrunning S).
If this is not convincing enough, try to think about a simpler problem at first, where no two segments can overlap. The solution is the same, but it's much more intuitive to see why it gives the right answer.

Answer 2

Shafa is Right;
#include <iostream>
#include <set>
using namespace std;
class Interval{
public:
int begin;int end;
Interval(){
begin=0;end=0;
}
Interval(int _b,int _e){
begin=_b;end=_e;
}
bool operator==(const Interval& i) const {
return (begin==i.begin)&&(end==i.end);
}
bool operator<(const Interval& i) const {
return begin<i.begin;
}
};
int n,t,a,b;
multiset<Interval> inters;
multiset<int> iends;
multiset<Interval>::iterator it1;
multiset<int>::iterator et1;
int main(){
scanf("%d",&t);
while(t--){
inters.clear();
iends.clear();
scanf("%d",&n);
while(n--){
scanf("%d %d",&a,&b);
Interval inter(a,b);
inters.insert(inter);
}
it1=inters.begin();
while(it1!=inters.end()){
iends.insert(it1->end);
et1=iends.lower_bound(it1->begin);
multiset<int>::iterator t=et1;
if((++et1!=iends.end())&&(++et1!=iends.end())){
//把剩下的线段全部删掉
while(et1!=iends.end()){
multiset<int>::iterator te=et1;
et1++;
iends.erase(te);
}
}
it1++;
}
printf("%d\n",iends.size());
}
system("pause");
return 0;
}