HDOJ 2037

#include<iostream>
using namespace std;

#include<vector>
#include<math.h>
#include<iomanip>
#include<string.h>

void swap(int &a,int &b)
{
        int c = a;
        a = b;
        b = c;
}

int partition(vector<int> &vs,vector<int> &ve,int start,int end)
{
        int a = vs[start];
        int b = ve[start];
        while(start < end)
        {
                while(start < end && vs[end] >= a) --end;
                if(start < end)
                {
                        vs[start] = vs[end];
                        ve[start] = ve[end];
                }
                while(start < end && vs[start] <= a) ++start;
                if(start < end)
                {
                        vs[end] = vs[start];
                        ve[end] = ve[start];
                }
        }
        vs[start] = a;
        ve[start] = b;
        return start;
}

void quickSort(vector<int> &vs,vector<int> &ve,int start,int end)
{
        if(start < end)
        {
                int pos = partition(vs,ve,start,end);
                quickSort(vs,ve,start,pos-1);
                quickSort(vs,ve,pos+1,end);
        }
}

int max(int count[],int start,int end)
{
        int c = count[start];
        for(int i = start+1;i < end;i++)
        {
                if(c < count[i]) c = count[i];
        }
        return c;
}

int findFirst(vector<int> vs,int a,int end)
{
        int i = 0;
        while(vs[i] < a && i <= end) i++;
        if(i > end) return -1;
        return i;
}

int main()
{
        int n,s,e,c,maxcount;
        while(cin>>n && n != 0)
        {
                c = 0;
                int count[n],i;
                memset(count,0,sizeof(int)*n);
                vector<int> vs,ve;
                for(i = 0;i < n;i++)
                {
                        cin>>s>>e;
                        vs.push_back(s);
                        ve.push_back(e);
                }
                quickSort(vs,ve,0,vs.size()-1);
                for(i = 1;i < vs.size();)
                {
                        while(vs[i] == vs[i-1])
                        {
                                ++c;
                                ++i;
                        }
                        quickSort(ve,vs,i-c-1,i-1);
                        c = 0;
                        ++i;
                }
                i = vs.size()-1;
                while(vs[i] == vs[i-1])
                {
                        count[i] = 1;
                        --i;
                }
                count[i] = 1;
                --i;
                maxcount = 1;
                for(;i >= 0;--i)
                {
                        int start = findFirst(vs,ve[i],vs.size()-1);
                        if(start == -1)
                        {
                                count[i] = 1;
                                continue;
                        }
                        count[i] = 1+max(count,start,vs.size()-1);
                        if(maxcount < count[i]) maxcount = count[i];
                }

                cout<<maxcount<<endl;
        }

        return 0;
}