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-
 ) {return fabs(one-another)<eps;}
 template<typename real>
 inline __function__(bool) funequals(
     const real&one,const real&another,const real&eps=1e-
 ) {return fabs(one-another)>=eps;}
 //} defs

 //geometry {
 template<typename T=double> struct Point
 {
     T x,y; Point(const T&_x=,const T&_y=):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>?(y<)**M_PI+atan(y/x):M_PI+atan(y/x);
     }
     __function__(double) theta_x()const{return x?atan(y/x):M_PI/;}
     __function__(double) theta_y()const{return y?atan(x/y):M_PI/;}
 };
 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,),pow(A.y-B.y,));
 }
 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=,const double&_b=):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)?:(k=double(A.y-B.y)/(A.x-B.x),b=A.y-k*A.x,);
     }
     __function__(double) theta_x()const{return atan(k);}
     __function__(double) theta_y()const{return theta_x()-M_PI/;}
     __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[],y[]; int stack[]; kbLine L[];

 int main()
 {
     scanf("%d",&n); REP(i,,n) scanf("%lf",x+i); REP(i,,n) scanf("%lf",y+i);
     REP(i,,n-) L[i].build_line(Point<>(x[i],y[i]),Point<>(x[i+],y[i+]));
     sort(L+,L+n); int top=stack[]=; REP(i,,n-)
     {
         for(;i<=n&&(L[i]==L[stack[top]]||parallel(L[i],L[stack[top]]));++i);
         for(;i<=n&&top>;--top)
         {
             Point<>*last=cross(L[stack[top-]],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=;
     REP(i,,n)
     {
         for(;L[stack[j]].get(x[i])>L[stack[j-]].get(x[i]);++j);
         ans=min(ans,L[stack[--j]].get(x[i])-y[i]);
     }
     REP(i,,top)
     {
         Point<>*now=cross(L[stack[i-]],L[stack[i]]);
         j=upper_bound(x+,x+n+,now->x)-x; kbLine tmp;
         tmp.build_line(Point<>(x[j-],y[j-]),Point<>(x[j],y[j]));
         ans=min(ans,now->y-tmp.get(now->x)); delete now;
     }
     return printf("%.3lf\n",ans),;
 }