// vc6下编译通过

// 为使用qsort进行数据比较
int cmp(const void*x, const void *y)
{
    return (*(int*)x - *(int*)y);
}

int MaxVisitors(int X[], int Y[], int n)
{
    qsort((void*)X, n, sizeof(int), cmp);
    qsort((void*)Y, n, sizeof(int), cmp);

    int        i, j;
    int        start_pos = 0;        // 进校循环起始位置
    int        max = 0;            // 最大车辆数

    for(i=0; i<n; ++i)
    {
        for(j = start_pos; j<n; ++j)
        {
            if(X[j] >= Y[i])
                break;
        }

        max = max<j-i?j-i:max;    // 只需要掌握在本时刻之前有多少辆车进入校园，多少辆出校园即可。
                                // j代表进入的车辆数，i代表出去的车辆数，二者之差就是本时刻
                                // 之前校园内的车辆数。
        if(j >= n)        // 进校情况循环完毕，则可以退出
            break;

        start_pos = j;
    }

    return max;
}

/*
解题思路：
本题实际上是求：至少要多少个停车位，才能让车辆不冲突。
解决本题有一个经典的贪心算法，即每次都将尽可能多的车辆安排到同一车位。
步骤如下：
1、按照车辆出校的时间排序，并置变量maxVisitors=0。
2、按排好的顺序，选出第一辆没有处理的车，标记为“已处理”。
   如果所有的车都是“已处理”，则结束，
   此时maxVisitors的值就是最少的车位数，也就是同一时刻最多的车数。
3、在2选出的车以后顺次查找，
   如果有时间上与上一个“已处理”的车不冲突的车，则标记为“已处理”。
4、第2，3步所选出的车可安排到同一停车位中，所以maxVisitors加1。
5、跳转至第2步，重复执行。
*/

#include <stdlib.h>

enum myBool { myFalse, myTrue };

typedef struct visitor
{
    int In;
    int Out;
    int checked;
}Visitor;

int VisitorCmp(const void *p1, const void *p2)
{
    return ((const Visitor*)p1)->Out - ((const Visitor*)p2)->Out;
}

int MaxVisitors(int X[], int Y[], int n)
{
    int i;
    int maxVisitors = 0;
    int PrevOut = 0;
    // 计算前，先把X和Y数组转化为Visitor数组，并根据出校时刻排序
    Visitor *visitors = (Visitor*)malloc(n*sizeof(Visitor));
    for(i=0; i<n; ++i)
    {
        visitors[i].In = X[i];
        visitors[i].Out = Y[i];
        visitors[i].checked = myFalse;
    }
    qsort(visitors, n, sizeof(Visitor), VisitorCmp);
    // 利用贪心法计算最优值
    for(;;)
    {
        // 找到一个还没有处理的车辆
        for(i=0; i<n; ++i)
            if( visitors[i].checked == myFalse )
                break;
        if( i==n )
            break;
        // 标记该车辆为“已处理”
        visitors[i].checked = myTrue;
        PrevOut = visitors[i].Out;
        // 从该车辆的下一个开始查找，如果有未处理的车辆，并且
        // 进校时间比上一个“已处理”车辆的出校时间还晚（也可以相等），
        // 也标记为“已处理”。
        for(++i; i<n; ++i)
        {
            if( visitors[i].checked )
                continue;
            if( visitors[i].In >= PrevOut )
            {
                visitors[i].checked = myTrue;
                PrevOut = visitors[i].Out;
            }
        }
        // 一轮循环中所有标记的车辆只需要一个车位就可以解决问题
        // maxVisitors加1
        ++maxVisitors;
    }
    // 释放资源并返回
    free(visitors);
    return maxVisitors;
}
//==================================================================
// 测试用的代码
#include <stdio.h>
int main()
{
    int Time_In[] = {1,2,4,5,3};
    int Time_Out[] = {4,4,7,6,9};
    int n = sizeof(Time_In) / sizeof(Time_In[0]);

    printf("%d\n", MaxVisitors(Time_In, Time_Out, n));

    return 0;
}

#include <iostream.h>
#include <stdlib.h>

int comp(const void* a,const void *b) 
{ 
    int *x=(int*)a; 
    int *y=(int*)b; 
    return *x-*y;   
}      

int MaxVisitors(int X[], int Y[], int n)
{
    int max=0,p1=0,p2=0,car=0;
    while(p1<n && p2<n)
    {
        if(X[p1]<Y[p2])
        {
            car++;
            p1++;
        }
        else if(X[p1]==Y[p2])
        {
            p1++;
            p2++;
        }
        else
        {
            if(car>0)
                car--;
            p2++;
        }
        if(car>max) max=car;
    }
    return max;
}

int main()
{
    int X[10000],Y[10000],n,i;
    cin>>n;
    for(i=0;i<n;i++)
        cin>>X[i]>>Y[i];
    qsort(X,n,sizeof(int),comp);
    qsort(Y,n,sizeof(int),comp);
    cout<<MaxVisitors(X, Y, n)<<endl;
}

#include "stdafx.h"
#include "stdlib.h"
#include "assert.h"

#define MAX_ITEM_COUNT 10000

typedef struct 
{
    int t[MAX_ITEM_COUNT*2];
    int c[MAX_ITEM_COUNT*2];
    int count;
}TIME_LIST;


int g_buff[MAX_ITEM_COUNT*2];
TIME_LIST g_timeList;


int __cdecl intCompare(const void *element1,const void *element2)
{
    int n1,n2;
    n1=*((int *)element1);
    n2=*((int *)element2);
    if (n1>n2)
        return 1;
    else if (n1<n2)
        return -1;
    else 
        return 0;
}

void CreateTimeOrderTable(int x[],int y[],int n,int T[],TIME_LIST *p)
{
    int i;
    int pre;
    for (i=0;i<n;i++)
    {
        T[i*2]=x[i];
        T[i*2+1]=y[i];
    }
    //-------------------------------
    qsort((void *)(T),n*2,sizeof(int),intCompare);
    //-----------------------------------------------
    p->count=1;
    pre=p->t[0]=T[0];
    i=1;
    while (1)
    {
        while ( i<2*n && T[i]==pre)
            i++;
        if (i==2*n)
            break;
        pre=p->t[p->count]=T[i];
        p->count++;
        i++;
    }
    for (i=0;i<p->count;i++)
        p->c[i]=0;
}

// 采用二分查找法在数组中查找关键字t,
// 返回下标
int SearchInTimeOrderTable(int t,TIME_LIST *p)
{
    int low,high,mid;

    low=0;
    high=p->count-1;

    while(high>low+1)
    {
        mid=(high+low)/2;
        
         if ( t < p->t[mid])
            high=mid-1;
        else if (t> p->t[mid] )
            low=mid+1;
        else
        {
            return mid;
        }
    }
    
    if ( t==p->t[low])
        return low;
    else if ( t== p->t[high] )
        return high;
    else 
    {
        assert(0);
        return -1;
    }
}

int MaxVisitors(int X[],int Y[],int n)
{
    int i,j;
    int max;
    CreateTimeOrderTable(X,Y,n,g_buff,&g_timeList);
    
    for (i=0;i<n;i++)
    {
        j=SearchInTimeOrderTable(X[i],&g_timeList);
        assert(j>=0);
        while (g_timeList.t[j] < Y[i])
        {
            g_timeList.c[j]++;
            j++;
        }
    }
    
    for (max=0,i=0;i<g_timeList.count;i++)
    {
        if (g_timeList.c[i]>max)
            max=g_timeList.c[i];
    }
    return max;
}

int MaxVisitors(int X[],int Y[],int n){
 int k,j,max=0,m[25]={0};
 for (k=0;k<n+1;k++)
   {
      for(j=X[k];j<Y[k];j++)
     m[j]++;
   }
 for (k=0;k<25;k++)
  { 
   if (max<m[k])
   max=m[k];
  }
 return max;
}

不明白如果一个车如果是4时刻进的，4时刻出那4时刻该怎么算？
还有一天的时刻是否是24小时，题目的时刻指的是什么，是小时还是分钟。
望能说的明白点。

#include <stdio.h>
#include<memory.h>
int x[10000],y[10000];
int count[10001];//记录各个时刻停车数 

int MaxVisitors(int X[], int Y[], int n)
{
  int num,max,num1,index;
  index=num1=n;
  memset(count,0,sizeof(count));
  while(n--){
    num=x[n];
    while(num<y[n])count[num++]++;
 }
 max=0;
 while(index--)
 {
  if(count[index]>max)max=count[index];
   num1-=count[index];
   if(num1<=max)break;
}
return max;
}
   

int main(int argc, char *argv[])
{
    int n,maxnum;
    while(scanf("%d",&n)!=EOF)
    {
       for(int i=0;i<n;i++)
           scanf("%d%d",&x[i],&y[i]);
       maxnum=MaxVisitors(x,y,n);
       printf("%d\n",maxnum);
    }
   return 0;
           
}

#include "stdio.h"
#include "memory.h"

#define NULL 0
#define N 10000

int MaxVisitors(int X[], int Y[], int n)
{
    int t_max=0;
    int v_max=0;
    for(register int i=0; i<n; i++)
    {
        if(t_max<Y[i])
            t_max=Y[i];
    }

    int *buf=new int[t_max];
    
    memset(buf,0,sizeof(buf)*t_max);

    for(i=0; i<n; i++)
    {
        for(register int j=X[i]; j<Y[i]; j++)
        {
            if(++buf[j-1]>v_max)
                v_max=buf[j-1];
        }
    }

    delete buf;
    return v_max;
}

int main(int argc, char* argv[])
{
    int *X=NULL;
    int *Y=NULL;

    int n=0;

    printf("Please input car's number:");
    scanf("%d",&n);

    if(n>N)
    {
        printf("The cars list is too long.");
        return -1;
    }

    X=new int[n];
    Y=new int[n];

    for(int i=0; i<n; i++)
    {
        printf("Please input car %d arrived time:",i+1);
        scanf("%d",&X[i]);
        printf("Please input car %d left time:",i+1);
        scanf("%d",&Y[i]);
    }

    int v=MaxVisitors(X,Y,n);

    printf("\nThe max visitors in this day is:%d\n",v);
    return 0;
}

int MaxVisitors2(int X[],int Y[],int n)
{
   int i,max=1,count,*p;
   for(p=X;p<X+n;p++)
   {count=0;i=0;
   for(i=0;i<n;i++)
   if(X[i]<=*p&&Y[i]>*p)  count++;
   max=count>max?count:max;
     }   
 return(max);
 }

int MaxVisitors(int X[], int Y[], int n)
{
    int tm[25] = {0};

    for (int i = 0; i < n; ++i)
        for (int j = X[i]; j < Y[i]; ++j)
            ++tm[j];

    int max = 0;
    for (int i = 0; i < 25; ++i)
        if (max < tm[i])
            max = tm[i];

    return max;
}

#include <stdlib.h>

int cmp( const void *a , const void *b ) 
{ 
return *(*(int **)a) - *(*(int **)b); 
} 

int MaxVisitors(int X[], int Y[], int n){
    int i;
    int j;
    int max;
    int end_time;
    int *tmp;
    int **p=new int*[n];
    int *used=new int[n];
    tmp=X;
    for (i=0;i<n;++i) {
        p[i]=tmp++;
        used[i]=0;
    }
    qsort(p,n,sizeof(p[0]),cmp);
    max=0;
    for (i=0;i<n;++i) {
        if (0==used[i]) {
            end_time=Y[p[i]-X];
            used[i]=1;
            for (j=i;j<n;++j) {
                if (0==used[j] && X[j]>=end_time) {
                    used[j]=1;
                    end_time=Y[p[j]-X];
                }
            }
            ++max;
        }
    }
    delete []p;
    return max;
}
//时间仓促没有加注释，不好意思啦，改了一次但愿这次没有错。。