quicksort+binarySearch

 

描述
数轴上有n个点，对于任一闭区间 [a, b]，试计算落在其内的点数。

输入
第一行包括两个整数：点的总数n，查询的次数m。

第二行包含n个数，为各个点的坐标。

以下m行，各包含两个整数：查询区间的左、右边界a和b。

输出
对每次查询，输出落在闭区间[a, b]内点的个数。

Example
Input

5 2
1 3 7 9 11
4 6
7 12
Output

0
3

限制
0 ≤ n, m ≤ 5×105

对于次查询的区间[a, b]，都有a ≤ b

各点的坐标互异

各点的坐标、查询区间的边界a、b，均为不超过10^7的非负整数

时间：2 sec

内存：256 MB

 

终于解决了《范围查询》算法这一题了，100分通过，得瑟一下！ 经历了55分，45分，0分，runtime error的越改越少的怪圈，在此说下心得：

先scanf再用new来保存数组的输入值long；然后快速排序;

然后用二分查找，分别找左边界，右边界不同的情况

如果左边界为其中某个数a[i],则说明不包含的个数为i

如果右边界为其中某个数a[i],则说明包含的个数为i+1

用右边界包含的个数减去左边界不包含的个数，就是[a,b]内的个数

还有一种情况是边界点不在坐标数组中，也好分析。 

找不到那个数，最后一步情况就是low=middle=high，循环退出时是low>high。也可以算出左边不包含和右边包含的数的个数

用的VC6++，个人觉得关键点有： ,scanf, new long[n], quickSort, binarySearch, delete[]

 

#include <cstdio> 
//#include <stdlib.h> 
//二分查找

long binary_search(long* a, long len, long goal);
void quicksort(long *a, long left, long right);

//左边界T，右边界F
long binary_search(long* a, long len, long goal, bool t)
{
    long low = 0;
    long high = len - 1;
    long middle;

    while(low <= high)
    {
        middle = (low + high)/2;
        if(goal == a[middle])
        {
            return (t ? middle: middle+1);
        }
        else if(goal < a[middle])//在左半边
            high = middle - 1;
        
        else//在右半边
            low = middle + 1;
    }//low>high
    if(goal < a[middle])
        return middle;
    else//if (goal > a[middle])
        return middle + 1;
}



void quicksort(long *a, long left,long right) 
{ 
    long i,j,t,temp; 
    if(left>right) 
       return; 
                                
    temp=a[left]; //temp中存的就是基准数 
    i=left; 
    j=right; 
    while(i<j) 
    { 
                   //顺序很重要，要先从右边开始找 小于基数的数
                   while(a[j]>=temp && i<j) 
                            j--; 
                   //再找左边的大于基数的数
                   while(a[i]<=temp && i<j) 
                            i++; 
                   //交换两个数在数组中的位置 
                   if(i<j) 
                   { 
                            t=a[i]; 
                            a[i]=a[j]; 
                            a[j]=t; 
                   } 
    } 
    //最终将基准数归位 
    a[left]=a[i]; 
    a[i]=temp; 
                             
    quicksort(a,left,i-1);//继续处理左边的，这里是一个递归的过程 
    quicksort(a,i+1,right);//继续处理右边的 ，这里是一个递归的过程 
} 




int main(void)
{
    long num, cmd;
    long i,ret1,ret2;

    scanf("%ld %ld",&num,&cmd);

    //long *n = (long*)malloc(num*4);
    long *n = new long[num];
    for (i=0;i<num;i++)
        scanf("%ld ",n+i);

    //long *src = (long*)malloc(cmd*4);
    //long *des = (long*)malloc(cmd*4);
    long *src = new long[cmd];
    long *des = new long[cmd];

    for (i=0;i<cmd;i++)
        scanf("%ld %ld",src+i,des+i);

    quicksort(n, 0, num-1);

/*    for (i=0;i<num;i++)
        printf("%d ",n[i]);*/

    for (i=0;i<cmd;i++)
    {
        ret1=binary_search(n,num,src[i],true);//find in n[], length num, goal src[i]
        ret2=binary_search(n,num,des[i],false);
        printf("%ld\n",ret2-ret1);
    }

    delete[] n;
    delete[] src;
    delete[] des;
    return 0;
}