【算法课】最大间隙问题

题目描述

给定 n 个实数，求这n个实数在数轴上相邻2个数之间的最大差值，设计解最大间隙问题的线性时间算法（时间复杂度为O(n)）。 

输入

第一行一个正整数n（2<=n<=2×1e7） 
第二行n个实数，数据保证这些实数只有一位小数。 

输出

一个实数，保留1位小数。

样例输入

5
2.3  3.1  7.5  1.5  6.3

样例输出

3.2

---

【参考博客】https://blog.csdn.net/llwwlql/article/details/52434280

【题解】

　　百思不得其解，为什么会用到鸽笼原理，后来老师讲解后，发现还真的是鸽笼原理。

　　核心思想是：

　　n个点，其中两个点作为左右边界。剩下n-2个点，在n-1个格子必定有一个为空。

　　比如：1,2,3,4。

　　那么利用1,4作为左右边界，然后剩下两个数字，我们把[1,4]这个区间等分划分成n-1个区间。

　　那么就会出现  [ 1 , 2 ] [ 2 , 3 ] [ 3 , 4 ] 这三个区间，剩下两个数字进行投球测试，必定有一个区间是空的。

　　最大的间隙必定会在这个空隙与左右区间的点结合后组成最大的间隙。

　　1、扫描　　找出所有点的最大值和最小值。

　　2、划分区间　　区间的长度为： len = ( Max - Min ) / ( n - 2 )  . 

　　3、处理每一个区间

　　　　　　a、求出每一个点对应在哪个区间，( a[i] - Min ) / ( len ) 

　　　　　　b、把每一个点都安放好对应的区间(Block)里面

　　　　　　c、顺便统计 区间里的个数，区间里的左右边界：即 在区间里的最大值和最小值。

　　4、然后过程中跑就行了，只需要在跑的过程中找出左边区间的最大值，和当前区间最小值进行更新答案，同时更新最后一个右端点。

　　5、特判两种情况：

　　　　　　a、如果第3步骤出现 长度等于0 时，区间编号求解时：len作为分母，出现这种情况其实答案直接输出0即可。

　　　　　　b、如果出现只有两个数的情况下，如果下标是从0开始更新的，如果处理不好就会在在第一个区间内不更新值。

　　

---

【代码1】

#include <stdio.h>
#define N 2e7+10
#define mmax 1e5
#define mmin 0

int n,count[N]={0};
double num[N], maxNum[N],minNum[N];


int main()
{
    int i,bucket;
    double maxValue=mmin, minValue=mmax,delta,begin,maxgap=0.,temp;

    scanf("%d",&n);

    //the first step, input and compute the max and min value.
    for(i=0;i<n;i++){
        scanf("%lf",&num[i]);
        maxNum[i]=mmin;
        minNum[i]=mmax;

        if(num[i]>maxValue)
            maxValue=num[i];

        if(num[i]<minValue)
            minValue=num[i];
    }

    //the second step, partion the numbers into buckets
    delta=(maxValue-minValue)/(n-1);


    if( delta == 0 ) {
        printf("0.0
");
        return 0 ;
    }

    for(i=0;i<n;i++){
        bucket=(int)((num[i]-minValue)/delta);
        count[bucket]++;
        if(maxNum[bucket]<num[i])
            maxNum[bucket]=num[i];
        if(minNum[bucket]>num[i])
            minNum[bucket]=num[i];
    }


    /*
    //deal with the last bucket, containing the max Number
    if(count[n-2]==0)
        minNum[n-2]=maxNum[n-2]=maxValue;
    else
        maxNum[n-2]=maxValue;

    count[n-2]++;
    */


    //the third step, retrieve the max gap
    begin=maxNum[0];

    //把 i < n - 1 改成 i < n
    for(i=1;i<n;i++){
        if(count[i]){
            temp=minNum[i]-begin;
            if(temp>maxgap)
                maxgap=temp;
            begin=maxNum[i];
        }
    }

    printf("%.1f
",maxgap);

    return 0;
}

【代码2】

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e7 + 10 ;
const double inf = 1e18 ;
double Block[N][2] , a[N] ;
double Max ;
double Min ;
double Len ;
int n,Cnt[N] ;

int main(){

    /*输入，同时更新最大最小值*/
    scanf("%d",&n);


    scanf("%lf",&a[1]);
    Max = a[1] ;
    Min = a[1] ;
    Block[1][0] =  inf ;
    Block[1][1] = -inf ;

    for( int i=2 ; i <= n ; i++ ){
        scanf("%lf",&a[i]);
        Max = max( Max , a[i] );
        Min = min( Min , a[i] );
        Block[i][0] =  inf ;
        Block[i][1] = -inf ;
    }

    /* 处理每一个间隙 */
    /* n 个点 n - 1 个区间 */
    Len = ( Max - Min ) / ( n - 1 ) ;

    if( n == 2 ){
        printf("%.1f
",Max-Min);
        return 0;
    }
    /* 扫描每一个点，把点放置在对应的Block里面 */
    for( int i = 1 ; i <= n ; i++ ){
        int idx = int( ( a[i] - Min ) / Len ) + 1 ;
        Cnt[idx] ++ ;
        Block[idx][0] = min( Block[idx][0] , a[i] );
        Block[idx][1] = max( Block[idx][1] , a[i] );
    }

    double Ans = 0 , Last = Min ;
    for( int i = 1 ; i <= n-1 ; i++ ){
        if( Cnt[i] ){
            if( Ans < Block[i][0] - Last ){
                Ans = Block[i][0] - Last ;
            }
            Last = Block[i][1];
        }
    }

    //特判最后一个点的位置

    if( Ans < Max - Last ){
        Ans = Max - Last ;
    }

    printf("%.1f
",Ans);
    return 0;
}

【代码3】

#include<bits/stdc++.h>
using namespace std;
#define Sheryang main
const int maxn=2e7+7;
typedef long long ll;
const int mod=1e9+7;
#define HEAP(...) priority_queue<__VA_ARGS__ >
#define heap(...) priority_queue<__VA_ARGS__,vector<__VA_ARGS__ >,greater<__VA_ARGS__ > > 
template<class T> inline void gmin(T &x,const T &y){x=x>y?y:x;}
template<class T> inline void gmax(T &x,const T &y){x=x<y?y:x;}
template<class T> inline bool Gmin(T &x,const T &y){return x>y?x=y,1:0;}
template<class T> inline bool Gmax(T &x,const T &y){return x<y?x=y,1:0;}
const int BufferSize=1<<16;
char buffer[BufferSize],*Bufferhead,*Buffertail;
bool Terminal;
inline char Getchar(){
    if(Bufferhead==Buffertail){
        int l=fread(buffer,1,BufferSize,stdin);
        if(!l){Terminal=1;return 0;}
        Buffertail=(Bufferhead=buffer)+l;
    }
    return *Bufferhead++;
}
template<class T>inline bool read(T &x){
    x=0;char c=Getchar(),rev=0;
    while(c<'0'||c>'9'){rev|=c=='-';c=Getchar();if(Terminal)return 0;}
    while(c>='0'&&c<='9') x=x*10+c-'0',c=Getchar();
    if(c=='.'){
        c=Getchar();double t=0.1;
        while(c>='0'&&c<='9') x=x+(c-'0')*t,c=Getchar(),t=t/10;
    }
    x=rev?-x:x;
    return 1;
}
template<class T1,class T2> inline bool read(T1 &x,T2 &y){return read(x)&read(y);}
template<class T1,class T2,class T3> inline bool read(T1 &x,T2 &y,T3 &z){return read(x)&read(y)&read(z);}
template<class T1,class T2,class T3,class T4> inline bool read(T1 &x,T2 &y,T3 &z,T4 &w){return read(x)&read(y)&read(z)&read(w);}
inline bool reads(char *x){
    char c=Getchar();
    while(c<33||c>126){c=Getchar();if(Terminal)return 0;}
    while(c>=33&&c<=126) (*x++)=c,c=Getchar();
    *x=0;return 1;
}
/** keep hungry and keep calm! **/
 
 
double a[maxn],Cage[maxn][2];
int cot[maxn];
int Sheryang(){
     
    //freopen("input.txt","r",stdin);
    //freopen("out1.txt","w",stdout);
     
    int n;read(n);
    for(int i=1;i<=n;i++){
        read(a[i]);
    }
     
    double Max = a[1],Min = a[1];
    for(int i=2;i<=n;i++){
        gmax(Max,a[i]);
        gmin(Min,a[i]);
    }
    double gap = (Max - Min) / (n-1);
     
    if(gap == 0){
        printf("0.0
");
        return 0;
    }
     
    for(int i=1;i<=n;i++){
        Cage[i][0] = 1e18;
        Cage[i][1] = -1e18;
    }
     
    for(int i=1;i<=n;i++){
        int pos = (int)((a[i] - Min)/gap) + 1;
        cot[pos] ++;
        gmin(Cage[pos][0],a[i]);
        gmax(Cage[pos][1],a[i]);
    }
     
    double last = Min, ans = 0;
    for(int i=1;i<=n;i++){
        if(cot[i]){
            double tmp = Cage[i][0] - last;
            if(tmp > ans){
                ans = tmp;
            }
            last = Cage[i][1];
        }
    }
    if(Max - last > ans){
        ans = Max - last;
    }
     
    printf("%.1f
",ans);
    return 0;
}