bzoj1038题解

【题意分析】

　　求一个下凸壳与一段折线的距离。

【解题思路】

　　先把直线按斜率排序，求出下凸壳，然后枚举所有的顶点的x坐标求最短y坐标差，复杂度O(nlog₂n)。

【参考代码】

#include <algorithm>
#include <cstdio>
#define REP(i,low,high) for(register int i=(low);i<=(high);++i)
#define __function__(type) /*__attribute__((optimize("-O2"))) inline */type
#define __procedure__ /*__attribute__((optimize("-O2"))) inline */void
using namespace std;
 
//defs {
#include <cmath>
template<typename real>
inline __function__(bool) fequals(
    const real&one,const real&another,const real&eps=1e-6
) {return fabs(one-another)<eps;}
template<typename real>
inline __function__(bool) funequals(
    const real&one,const real&another,const real&eps=1e-6
) {return fabs(one-another)>=eps;}
//} defs
 
//geometry {
template<typename T=double> struct Point
{
    T x,y; Point(const T&_x=0,const T&_y=0):x(_x),y(_y) {}
    __function__(bool) operator==(const Point<T>&thr)const
    {
        return fequals(x,thr.x)&&fequals(y,thr.y);
    }
    __function__(bool) operator!=(const Point<T>&thr)const
    {
        return funequals(x,thr.x)||funequals(y,thr.y);
    }
    __function__(Point<T>) operator+(const Point<T>&thr)const
    {
        return Point<T>(x+thr.x,y+thr.y);
    }
    __function__(Point<T>) operator-(const Point<T>&thr)const
    {
        return Point<T>(x-thr.x,y-thr.y);
    }
    __function__(Point<T>) operator*(const T&lambda)const
    {
        return Point<T>(x*lambda,y*lambda);
    }
    __function__(Point<double>) operator/(const T&lambda)const
    {
        return Point<double>(double(x)/lambda,double(y)/lambda);
    }
    __function__(double) theta()const
    {
        return x>0?(y<0)*2*M_PI+atan(y/x):M_PI+atan(y/x);
    }
    __function__(double) theta_x()const{return x?atan(y/x):M_PI/2;}
    __function__(double) theta_y()const{return y?atan(x/y):M_PI/2;}
};
template<typename T>
inline __function__(T) dot_product(const Point<T>&A,const Point<T>&B)
{
    return A.x*B.x+A.y*B.y;
}
template<typename T>
inline __function__(T) cross_product(const Point<T>&A,const Point<T>&B)
{
    return A.x*B.y-A.y*B.x;
}
template<typename T>
inline __function__(double) Euclid_distance(const Point<T>&A,const Point<T>&B)
{
    return sqrt(pow(A.x-B.x,2),pow(A.y-B.y,2));
}
template<typename T>
inline __function__(T) Manhattan_distance(const Point<T>&A,const Point<T>&B)
{
    return fabs(A.x-B.x)+fabs(A.y-B.y);
}
struct kbLine
{
    //line:y=kx+b
    double k,b; kbLine(const double&_k=0,const double&_b=0):k(_k),b(_b) {}
    __function__(bool) operator==(const kbLine&thr)const
    {
        return fequals(k,thr.k)&&fequals(b,thr.b);
    }
    __function__(bool) operator!=(const kbLine&thr)const
    {
        return funequals(k,thr.k)||funequals(b,thr.b);
    }
    __function__(bool) operator<(const kbLine&thr)const{return k<thr.k;}
    __function__(bool) operator>(const kbLine&thr)const{return k>thr.k;}
    template<typename T>
    __function__(bool) build_line(const Point<T>&A,const Point<T>&B)
    {
        return fequals(A.x,B.x)?0:(k=double(A.y-B.y)/(A.x-B.x),b=A.y-k*A.x,1);
    }
    __function__(double) theta_x()const{return atan(k);}
    __function__(double) theta_y()const{return theta_x()-M_PI/2;}
    __function__(double) get(const double&x)const{return k*x+b;}
};
__function__(bool) parallel(const kbLine&A,const kbLine&B)
{
    return A!=B&&(fequals(A.k,B.k)||A.k!=A.k&&B.k!=B.k);
}
__function__(Point<double>*) cross(const kbLine&A,const kbLine&B)
{
    if(A==B||parallel(A,B)) return NULL; double _x=double(B.b-A.b)/(A.k-B.k);
    Point<double>*ret=new Point<double>(_x,A.k*_x+A.b); return ret;
}
//} geometry
 
static int n; double x[310],y[310]; int stack[310]; kbLine L[310];
 
int main()
{
    scanf("%d",&n); REP(i,1,n) scanf("%lf",x+i); REP(i,1,n) scanf("%lf",y+i);
    REP(i,1,n-1) L[i].build_line(Point<>(x[i],y[i]),Point<>(x[i+1],y[i+1]));
    sort(L+1,L+n); int top=stack[1]=1; REP(i,2,n-1)
    {
        for(;i<=n&&(L[i]==L[stack[top]]||parallel(L[i],L[stack[top]]));++i);
        for(;i<=n&&top>1;--top)
        {
            Point<>*last=cross(L[stack[top-1]],L[stack[top]]),
                   * now=cross(L[     i      ],L[stack[top]]);
            if(last->x<now->x) break; delete last; delete now;
        }
        stack[++top]=i;
    }
    double ans=1e10; int j=2;
    REP(i,1,n)
    {
        for(;L[stack[j]].get(x[i])>L[stack[j-1]].get(x[i]);++j);
        ans=min(ans,L[stack[--j]].get(x[i])-y[i]);
    }
    REP(i,2,top)
    {
        Point<>*now=cross(L[stack[i-1]],L[stack[i]]);
        j=upper_bound(x+1,x+n+1,now->x)-x; kbLine tmp;
        tmp.build_line(Point<>(x[j-1],y[j-1]),Point<>(x[j],y[j]));
        ans=min(ans,now->y-tmp.get(now->x)); delete now;
    }
    return printf("%.3lf
",ans),0;
}