PAT---完美数列

由于数值比较大，选用long型的

　　先用快速排序方法对数组进行排序，然后进行查找。

　　用一个问题是所要查找的数可能不在数组中，因此不能用现成的二叉查找法。试着对二叉查找法进行改进，单没调通。

　　在查找过程中，由于是查找最大值，而且数据是经过升序排序后的。所以最大值应该离数组末端近一些，故最开始的想法是从后往前顺序查找。

　　但这样有一组测试始终超时。

　　后来想了一个缩短查找时间的发放。就是从前往后查找。，但每次查找的起点是前一个数据的最大值的位置。至于前一个最大值的位置，是在每次查找到最大值后，记录了其位置。

　　网上有一种方法是用最小值的位置加上已找到的最大队列个数的值作为本轮查找的起始位置。

　　相比而言，该方法与我的方法思想都一样，但是其效率应该更高。　　

　　因为其是在已找到的最大个数的基础上先判断本数列的个数会不会大于前面的最大个数，如果会，则继续查找，找到最大个数。如果不会，直接进行下一个最小数的查找，其避免了不必要的查找。

　　而我的方法是先找出当前数能得到的最大数列的个数，在比较该个数是否大于前面的个数。这样可以求出每个数对应的最大数列。　　

　　我的方法主要在于进行了不必要的查找。

我的方法的code：

#include<iostream> 
#include<vector>
#include<algorithm>

using namespace std;

void quicksort(vector<long>& num,long left,long right)
{
    if(left>=right)
        return;
    long low=left;
    long high=right;
    long key=num[left];    
    long tmp;
    
    while(low<high)
    {
        while(high>low && num[high]>=key)
            high--;
        while(high>low && num[low]<=key)
            low++;
        if(low<high)
        {
            tmp=num[low];
            num[low]=num[high];
            num[high]=tmp;
        }
    }
    
    num[left]=num[low];
    num[low]=key;
    
    quicksort(num,left,low-1);
    quicksort(num,low+1,right);
}

/*
long binaryserach(vector<long> & a,long value,long low,long high)
{
    long mid=(low+high)/2;
    if(a[mid]==value)
        return mid;
    if(a[mid]>value)
    {
        if(a[mid-1]>value)
            return binaryserach(a,value,low,mid-1);
        else
            return mid-1;
    }
    if(a[mid]<value)
    {
        if(a[mid+1]>value)
            return mid;
        if(a[mid+1]==value) 
            return mid+1;
        if(a[mid+1]<value)
            return binaryserach(a,value,mid+1,high);
    }   
     
}*/

int main()
{
    long p,tmp,max;
    long N,count=1;
    
    cin >>N>>p;
    
    vector<long> number;
    
    for(long i=0;i<N;i++)
    {
        cin>>tmp;
        number.push_back(tmp);
    }    
    
    quicksort(number,0,number.size()-1);
    
    long right=0;
/*    long left,right;
    
    for(long i=0;i<number.size();i++)
        if(number[i]*p>=number[number.size()-1])
        {
            left=i;
            break;
        }*/
    
    for(long i=0;i<number.size();i++) 
    {
        //max=number[i]*p;
        for(long j=right;j<number.size();j++)
            if(number[j]<=number[i]*p)
            {
                right=j;
                if(count<j-i+1)
                    count=j-i+1;
            }        
            else
                break;
    }
    cout<<count<<endl;
     
    return 0;
} 

网上的方法：

#include<iostream> 
#include<vector>
#include<algorithm>

using namespace std;

void quicksort(vector<long>& num,long left,long right)
{
    if(left>=right)
        return;
    long low=left;
    long high=right;
    long key=num[left];    
    long tmp;
    
    while(low<high)
    {
        while(high>low && num[high]>=key)
            high--;
        while(high>low && num[low]<=key)
            low++;
        if(low<high)
        {
            tmp=num[low];
            num[low]=num[high];
            num[high]=tmp;
        }
    }
    
    num[left]=num[low];
    num[low]=key;
    
    quicksort(num,left,low-1);
    quicksort(num,low+1,right);
}


int main()
{
    long p,tmp,max;
    long N,count=1;
    
    cin >>N>>p;
    
    vector<long> number;
    
    for(long i=0;i<N;i++)
    {
        cin>>tmp;
        number.push_back(tmp);
    }    
    
    quicksort(number,0,number.size()-1);
    
    
    for(long i=0;i<number.size();i++) 
    {
        for(long j=i+count-1;j<number.size();j++)
            if(number[j]<=number[i]*p)
            {
                if(count<j-i+1)
                    count=j-i+1;
            }        
            else
                break;
    }
    cout<<count<<endl;
     
    return 0;
}