ACM模版——应用篇

排序与查找

//===========================================\\

|    快速排序                                |

\\===========================================//

bool cmp(int a,int b) //降序

{

    return a>b;

}

bool cmp(type a, type b)  //先按x降序，再按y降序

{

    if ( a.x==b.x ) return  a.y>b.y;

    else return a.x>b.x;

}

sort(s, s+n, cmp); 

- - - - - - - - - - - - - - - - - - - - - -

bool cmp(type a,type b)   //先按x降序，再按y升序

{

    if ( a.x==b.x ) return a.y>b.y;

    else return a.x<b.x;

}

void qsort(type *s,int l,int r)

{

    int i=l,j=r;

    while ( i<j )

    {

        while ( j>i && cmp(s[i],s[j]) ) j--;

        if ( j>i ) { swap(s+i,s+j); i++; }

        while ( i<j && cmp(s[i],s[j]) ) i++;

        if ( i<j ) { swap(s+i,s+j); j--; }

    }

    if ( l<i ) qsort(s,l,i-1);

    if ( j<r ) qsort(s,j+1,r);

}

//===========================================\\

|    归并排序                                |

\\===========================================//

void msort(int l,int r)

{

    int mid,i,j,t,k;

    if ( l==r ) return ;

    mid=(l+r)/2;

    msort(l,mid);

    msort(mid+1,r);

    i=l;

    j=mid+1;

    t=l;

    while ( 1 )

    {

        if ( s[i]<=s[j] ) a[t++]=s[i++];

        else { a[t++]=s[j++]; ans+=mid-i+1; }

        if ( i>mid )

        {

            for ( k=j; k<=r; a[t++]=s[k++] );

            break;

        }

        if ( j>r )

        {

            for ( k=i; k<=mid; a[t++]=s[k++] );

            break;

        }

    }

    for (k=l; k<=r; k++) s[k]=a[k];

}

//===========================================\\

|    二分查找—找答案（解方程）              |

\\===========================================//

double sr(double l,double r)

{

    double ans;

    while ( r-l>0.0001 )

    {

        ans=(l+r)/2.0;

        if ( f(ans)==0 ) return ans;

        else if ( f(ans)>0 ) r=ans;

        else l=ans;

    }

    return ans;

}

//===========================================\\

|    二分查找—找位置（绝对等于）            |

\\===========================================//

int sr(int y, int l, int r, int s[])

{

    int ans;   //  s[]升序

    while ( l<r )

    {

        ans=(l+r)/2;

        if ( s[ans]==y ) return ans;

        else if ( s[ans]>y ) r=ans-1;

        else l=ans+1;

    }

    if ( s[l]==y ) return l;

    else return -1;

}

//===========================================\\

|    二分查找—找位置（大于等于y的）        |

\\===========================================//

int sr(int y, int l, int r, int s[])

{

    int ans;

    while ( l<r )

    {

        ans=(l+r)/2;

        if ( s[ans]<y ) l=ans+1;

        else r=ans;

    }

    return l; // ans未更新，所以输出l

}

//===========================================\\

|    三分查找                                |

\\===========================================//

double sr(double l,double r)  //找最大值

{

    double lans,rans;

    while ( r-l>0.0000001 )

    {

        lans=l+(r-l)/3;

        rans=r-(r-l)/3;

        if ( f(lans)>f(rans) ) r=rans;

        else l=lans;

    }

    return f(lans);

}

//===========================================\\

|    交换函数                                |

\\===========================================//

struct type

{

    int a,b;

    char c;

};

void swap(type *a,type *b)

{

    type t=*a;

    *a=*b;

    *b=t;

}