POJ 3384

题目大意：

给定一个多边形，给定一个圆的半径，要求在多边形中放置两个同样半径的圆，可相互覆盖，但不能超出多边形的范围，希望两个圆的面积覆盖和最大

输出任意一组满足的圆的圆心点

如果两个圆不相互覆盖，那么必然达到最大面积

如果相互覆盖，可以换一种方式考虑，因为两个圆是一样的，两个圆的距离越长，那么相互覆盖的面积必然越小

所以可以将多边形内推进半径的长度

然后在半平面交后得到的多边形中找到距离最远的两个点

仔细想一想可以知道多边形上最远距离的点，必然是两个顶点的距离

所以平方的方法就可以求解了

当然用旋转卡壳的话在n的复杂度内就可以完美解决也是可行的

这里就用第一种简单的方法了

这里感觉精度卡的比较严，之前没写dcmp就一直过不了，尝试着加了一些精确度判断就a了

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <cmath>
 using namespace std;
 #define N 105
 #define eps 1e-9

 int dcmp(double x)
 {
     if(fabs(x)<eps) return ;
     return x<?-:;
 }

 struct Point{
     double x , y;
     Point(double x= , double y=):x(x),y(y){}
     void input(){scanf("%lf%lf" , &x , &y);}
     double dis(Point m){
         return (x-m.x)*(x-m.x)+(y-m.y)*(y-m.y);
     }
 }p[N] , poly[N];

 typedef Point Vector;

 struct Line{
     Point p;
     Vector v;
     double ang;
     Line(){}
     Line(Point p , Vector v):p(p),v(v){ang = atan2(v.y , v.x);}
     bool operator<(const Line &m) const{
         return dcmp(ang-m.ang)<;
     }
 }line[N];

 Vector operator+(Vector a , Vector b){return Vector(a.x+b.x , a.y+b.y);}
 Vector operator-(Vector a , Vector b){return Vector(a.x-b.x , a.y-b.y);}
 Vector operator*(Vector a , double b){return Vector(a.x*b , a.y*b);}
 Vector operator/(Vector a , double b){return Vector(a.x/b , a.y/b);}

 double Cross(Vector a , Vector b){return a.x*b.y-a.y*b.x;}
 double Dot(Vector a , Vector b){return a.x*b.x+a.y*b.y;}
 double Len(Vector a){return sqrt(Dot(a , a));}

 Vector Normal(Vector a)
 {
     double l = Len(a);
     return Vector(-a.y , a.x)/l;
 }

 bool OnLeft(Line L , Point p)
 {
     return dcmp(Cross(L.v , p-L.p))>=;
 }

 Point GetIntersection(Line a , Line b)
 {
     Vector u = a.p-b.p;
     double t = Cross(b.v , u)/Cross(a.v , b.v);
     return a.p+a.v*t;
 }

 int HalfplaneIntersection(Line *L , int n , Point *poly)
 {
     sort(L , L+n);
     int first , last;
     Point *p = new Point[n];
     Line *q = new Line[n];
     q[first=last=]=L[];
     for(int i= ; i<n ; i++){
         while(first<last && !OnLeft(L[i] , p[last-])) last--;
         while(first<last && !OnLeft(L[i] , p[first])) first++;
         q[++last] = L[i];
         if(fabs(Cross(q[last].v , q[last-].v))<eps){
             last--;
             if(OnLeft(q[last] , L[i].p)) q[last] = L[i];
         }
         if(first<last) p[last-] = GetIntersection(q[last-] , q[last]);
     }
     while(first<last && !OnLeft(q[first] , p[last-])) last--;
     if(last-first<=) return ;
     p[last] = GetIntersection(q[last] , q[first]);
     int m= ;
     for(int i=first ; i<=last ; i++) poly[m++] = p[i];
     return m;
 }

 int n;
 double r;

 int main()
 {
   //  freopen("in.txt" , "r" , stdin);
     while(~scanf("%d%lf" , &n , &r)){
         for(int i= ; i<n ; i++) p[i].input();
         p[n] = p[];
         for(int i= ; i<n ; i++){
             Vector v = p[i]-p[i+];
             Vector t = Normal(v)*r;
             line[i] = Line(p[i]+t , v);
         }
         int k = HalfplaneIntersection(line , n , poly);
         Point p1=poly[] , p2=poly[];
         double maxn = ;
      //   for(int i=0 ; i<k ; i++) cout<<poly[i].x<<" "<<poly[i].y<<endl;
         for(int i= ; i<k ; i++){
             for(int j= ; j<k ; j++){
                 if(poly[i].dis(poly[j])-maxn>eps){
                     p1 = poly[i] , p2 = poly[j];
                     maxn = poly[i].dis(poly[j]);
                 }
             }
         }
         printf("%.4f %.4f %.4f %.4f\n" , p1.x , p1.y , p2.x , p2.y);
     }
     return ;
 }