二维几何模版

转自：http://bbs.byr.cn/#!article/ACM_ICPC/63442

/* 
     Project: AkemiHomura's Standard Code Library [AHSCL] 
     Author: [BUPT]AkemiHomura@PuellaMagi 
     Category: Geometry 
     Title: Geometry Base Header 
     Version: 0.103 
     Date: 2011-5-3 
     Remark: Structure definations and base functions 
     Tested Problems: N/A 
     Tag: Geometry 
     Special Thanks: Amber, eucho@PuellaMagi, mabodx@PuellaMagi 
 */
   
 #ifndef GEOMETRY_BASE_H 
 #define GEOMETRY_BASE_H 
   
 #include <cstdio> 
 #include <cmath> 
 #include <algorithm> 
 using namespace std; 
   
 /***<常量表****/
 const int MAXN = 1000; 
 const double INF = 1e9; 
 const double EPS = 1e-8; 
 const double PI = acos(-1.0); 
 /****常量表>***/
   
 /***<浮点函数****/
 inline int sgn(double d) 
 { 
     if (fabs(d) < EPS) return 0; 
     return d>0 ? 1: -1; 
 } 
   
 inline double min(double a, double b) 
 {return a<b ? a : b;} 
   
 inline double max(double a, double b) 
 {return a>b ? a : b;} 
 /****浮点函数>***/
   
 /*******<平面几何********/
   
 /***<点/向量定义与运算****/
 struct sp { 
     double x, y; 
     double d, a; 
     int id; 
     sp() {} 
     sp(double xx, double yy): x(xx), y(yy) {} 
     bool read() {return scanf("%lf%lf", &x, &y)==2;} 
     void write() {printf("%f %f\n", x, y);} 
 }; 
   
 inline sp operator- (const sp &u, const sp &v) 
 {return sp(u.x-v.x, u.y-v.y);} 
   
 inline sp operator+ (const sp &u, const sp &v) 
 {return sp(u.x+v.x, u.y+v.y);} 
   
 inline sp operator* (double d, const sp &v) 
 {return sp(v.x*d, v.y*d);} 
   
 inline bool operator== (const sp &u, const sp &v) 
 {return sgn(u.x-v.x)==0 && sgn(u.y-v.y)==0;} 
   
 inline bool operator!= (const sp &u, const sp &v) 
 {return !(u == v);} 
   
 const sp ORIGIN = sp(0, 0); 
 /****点/向量定义与运算>***/
   
 /***<线段/直线定义****/
 struct ss { 
     sp a, b; 
     ss() {} 
     ss(sp u, sp v): a(u), b(v) {} 
 }; 
 /****线段/直线定义>***/
   
 /***<点与线基本函数****/
 //向量范数平方 
 double nrmsqr(const sp &v) 
 {return v.x*v.x + v.y*v.y;} 
   
 //点积 
 double dot(const sp &u, const sp &v) 
 {return u.x*v.x + u.y*v.y;} 
   
 //叉积 
 double det(const sp &u, const sp &v) 
 {return u.x*v.y - v.x*u.y;} 
   
 //(u-p)x(v-p) 
 //等于0表示3点共线 
 //大于0表示pv在pu的逆时针，小于0表示pv在pu的顺时针 
 double dir(const sp &p, const sp &u, const sp &v) 
 {return det(u-p, v-p);} 
   
 //两点距离 
 double dis(const sp &u, const sp &v) { 
     double dx = u.x-v.x; 
     double dy = u.y-v.y; 
     return sqrt(dx*dx+dy*dy); 
 } 
   
 //两点距离平方，针对精度问题 
 double dissqr(const sp &u, const sp &v) 
 {return nrmsqr(v-u);} 
   
 //点到直线距离 
 double disptoline(const sp &p, const ss &s) 
 {return fabs(det(p-s.a, s.b-s.a))/dis(s.b, s.a);} 
   
 //点到线段最近点 
 sp ptoseg(const sp &p, const ss &s) { 
     sp v = s.b-s.a, res; 
     double t = (dot(p, v)-dot(s.a, v))/dot(v, v); 
     if (sgn(t)>=0 && sgn(t-1)<=0) 
         res = s.a+(t*v); 
     else
         res = dis(p, s.a)<dis(p, s.b) ? s.a : s.b; 
     return res; 
 } 
   
 //点到线段距离 
 double disptoseg(const sp &p, const ss &s) 
 {return dis(p, ptoseg(p, s));} 
   
 //p相对p0极角 
 double pa(const sp &p, const sp &p0 = ORIGIN) 
 {return atan2(p.y-p0.y, p.x-p0.x);} 
   
 //将点p绕点p0旋转a弧度 
 sp rotate(const sp &p, double a, const sp &p0 = ORIGIN) { 
     sp res = p0, v = p-p0; 
     double c = cos(a), s = sin(a); 
     res.x += v.x*c-v.y*s; 
     res.y += v.x*s+v.y*c; 
     return res; 
 } 
   
 //判三点共线 
 bool coline(const sp &p0, const sp &p1, const sp &p2) 
 {return sgn(dir(p0, p1, p2))==0;}     
   
 //点p是否在直线s上 
 bool online(const sp &p, const ss &s) 
 {return coline(p, s.a, s.b);} 
   
 //点p是否在线段s上 
 bool onseg(const sp &p, const ss &s) 
 {return online(p, s) && (s.a.x-p.x)*(s.b.x-p.x)<EPS && (s.a.y-p.y)*(s.b.y-p.y)<EPS;} 
   
 //判两点在线段同侧，点在线段上返回0 
 bool sameside(const sp &u, const sp &v, const ss &s) 
 {return dir(s.b, s.a, u)*dir(s.b, s.a, v)>EPS;} 
   
 //判两点在线段异侧，点在线段上返回0 
 bool oppositeside(const sp &u, const sp &v, const ss &s) 
 {return dir(s.b, s.a, u)*dir(s.b, s.a, v)<-EPS;} 
   
 //直线u和v是否相交 
 bool lineint(const ss &u, const ss &v) 
 {return sgn(det(u.b-u.a, v.b-v.a))!=0;} 
   
 //线段u和v是否相交（包括端点） 
 bool segint(const ss &u, const ss &v) { 
     if (!coline(u.a, u.b, v.a) || !coline(u.a, u.b, v.b)) 
         return !sameside(u.a, u.b, v) && !sameside(v.a, v.b, u); 
     else
         return onseg(u.a, v) || onseg(u.b, v) || onseg(v.a, u) || onseg(v.b, u); 
 } 
   
 //计算两直线交点，结果赋予p 
 //返回值: 0 共线, 1 平行, 2 相交 
 char lineintp(const ss &u, const ss &v, sp &p) { 
     double a1, b1, c1, a2, b2, c2; 
     a1 = u.b.y - u.a.y; 
     b1 = u.a.x - u.b.x; 
     c1 = det(u.b, u.a); 
     a2 = v.b.y - v.a.y; 
     b2 = v.a.x - v.b.x; 
     c2 = det(v.b, v.a); 
     //判断是否共线或平行，确定相交时可以去掉 
     if (sgn(a1*b2-b1*a2)==0) 
         //There may be some mistakes 
         if (sgn(det(u.a-v.a, u.a-v.b))==0) return 0; 
         else return 1; 
     else
     { 
         double t = a2*b1-a1*b2; 
         p.x = (b2*c1-b1*c2)/t; 
         p.y = (a1*c2-a2*c1)/t; 
         return 2; 
     } 
 } 
 /****点与线基本函数>***/
   
 /***<面积****/
 //三角形三个点有向面积 
 double area(const sp &a, const sp &b, const sp &c) 
 {return dir(a, b, c)/2;} 
 //三角形三条边面积 
 double area(double p, double q, double r) { 
     double s = (p+q+r)/2; 
     return sqrt(s*(s-p)*(s-q)*(s-r)); 
 } 
   
 //多边形面积 
 double area(int N, sp poly[]) { 
     double res = 0; 
     if (N < 3) return 0; 
     for (int i = 0; i < N; ++i) 
         res += det(poly[i], poly[(i+1)%N]); 
     return res/2; 
 } 
 /****面积>***/
   
 /***<圆****/
 //判直线和圆相交（包括相切） 
 bool linecirint(const sp &c, double r, const ss &s) 
 {return sgn(disptoline(c, s)-r)<=0;} 
   
 //求点到圆的切点 
 //求出后可直接求切线 
 //点在圆内返回0，圆上返回1与点本身，否则返回2与两个切点 
 char tgp(const sp &c, double r, const sp &p, sp &u, sp &v) { 
     char cv = sgn(dis(p, c)-r); 
     if (cv < 0) return 0; 
     if (cv == 0) {u = p; return 1;} 
     double a = pa(p, c); 
     double da = acos(r/dis(p, c)); 
     u.x = c.x+r*cos(a+da); u.y = c.y+r*sin(a+da); 
     v.x = c.x+r*cos(a-da); v.y = c.y+r*sin(a-da); 
     return 2; 
 } 
   
 //两圆外公切线 
 //输入两圆心和半径 
 //返回两直线s和t 
 //s和t的a对应u上切点，b对应v上切点 
 void cotgl(const sp &u, double ru, const sp &v, double rv, ss &s, ss &t) { 
     double dr = ru-rv; 
     double d = dis(u, v); 
     double a = acos(dr/d); 
     sp dv = v-u; 
     s.a = u+ru/d*rotate(dv, a); s.b = v+rv/d*rotate(dv, a); 
     t.a = u+ru/d*rotate(dv, -a); t.b = v+rv/d*rotate(dv, -a); 
 } 
   
 //两圆内公切线 
 //输入两圆心和半径 
 //返回两直线s和t 
 //s和t的a对应u上切点，b对应v上切点 
 void citgl(const sp &u, double ru, const sp &v, double rv, ss &s, ss &t) { 
     double dr = ru+rv; 
     double d = dis(u, v); 
     double a = acos(dr/d); 
     sp dv = v-u; 
     s.a = u+ru/d*rotate(dv, a); s.b = v+rv/d*rotate(dv, a-PI); 
     t.a = u+ru/d*rotate(dv, -a); t.b = v+rv/d*rotate(dv, PI-a); 
 } 
   
 //求三点共圆 
 //共圆返回true，并返回圆心，半径，否则返回false 
 bool concylic(const sp &p1, const sp &p2, const sp &p3, sp &c, double r) { 
     if (sgn(dir(p1, p2, p3))==0) return 0; 
     double t1 = nrmsqr(p1)-nrmsqr(p2); 
     double t2 = nrmsqr(p1)-nrmsqr(p3); 
     double t3 = 2*(p1.x-p2.x)*(p1.y-p3.y)-2*(p1.x-p3.x)*(p1.y-p2.y); 
     c.x = ((p1.y-p3.y)*t1-(p1.y-p2.y)*t2)/t3; 
     c.y = -((p1.x-p3.x)*t1-(p1.x-p2.x)*t2)/t3; 
     r = dis(c, p1); 
     return 1; 
 } 
 /****圆>***/
   
 /***<多边形****/
 //多边形p是否以逆时针顺序给出 
 bool ccw(int N, sp p[]) { 
     double cnt = 0; 
     for (int i = 0; i < N; ++i) 
         cnt += dir(p[i], p[(i+1)%N], ORIGIN); 
     return sgn(cnt) > 0; 
 } 
   
 //点p是否在凸多边形c内 
 //输入：N为凸多边形点数，c为凸多边形，p为点。c中的点必须按逆时针序给出。 
 //输出：返回1表示（严格）在内部，0表示不在内部。 
 bool inside(int N, sp c[], sp p) { 
     int l=1, r=N-1, m; 
     while (l < r) 
     { 
         m = l+r>>1; 
         if (sgn(dir(c[0], c[m], p)) <= 0) 
             r = m; 
         else
             l = m+1; 
     } 
     if (r==1 || sgn(dir(c[0], c[N-1], p))>=0 || sgn(dir(c[r], c[r-1], p))>=0) return 0; 
     return 1; 
 } 
   
 //多边形切割 
 //将N个点的多边形p（逆时针输入）按直线s切割，留下side方向的部分 
 //剩下的部分返回在q(逆时针），返回q的点数 
 //可用于半平面交和多边形交 
 int polycut(int N, sp p[], const ss &s, const sp &side, sp q[]) { 
     sp pp[111]; 
     int M = 0, res = 0, i; 
     for (i = 0; i < N; ++i) { 
         if (sameside(p[i], side, s)) 
             pp[M++] = p[i]; 
         if (!sameside(p[i], p[(i+1)%N], s) 
             && !(sgn(dir(s.b, p[i], s.a))==0 
             && sgn(dir(s.b, p[(i+1)%N], s.a))==0)) 
             lineintp(ss(p[i], p[(i+1)%N]), s, pp[M++]); 
     } 
     for (res = i = 0; i < M; ++i) { 
         if (!i || sgn(pp[i].x-pp[i-1].x)!=0 || sgn(pp[i].y-pp[i-1].y)!=0) 
             q[res++] = pp[i]; 
     } 
     if (sgn(q[res-1].x-q[0].x)==0 && sgn(q[res-1].y-q[0].y)==0) 
         res--; 
     if (res < 3) res = 0; 
     return res; 
 } 
 /****多边形>***/
   
 //两圆交点 
 //返回两圆是否相交（相切不算） 
 //交点返回在a和b中 
 bool cirint(const sp &u, double ru, const sp &v, double rv, sp &a, sp &b) { 
     double d = dis(u, v); 
     if (sgn(d-(ru+rv))>=0 || sgn(d-fabs(ru-rv))<=0) return 0; 
     sp c = u-v; 
     double ca, sa, cb, sb, csum, ssum; 
   
     ca = c.x/d, sa = c.y/d; 
     cb = (rv*rv+d*d-ru*ru)/2/rv/d, sb = sqrt(1-cb*cb); 
     csum = ca*cb-sa*sb; 
     ssum = sa*cb+sb*ca; 
     a = sp(rv*csum, rv*ssum); 
     a = a+v; 
   
     sb = -sb; 
     csum = ca*cb-sa*sb; 
     ssum = sa*cb+sb*ca; 
     b = sp(rv*csum, rv*ssum); 
     b = b+v; 
   
     return 1; 
 } 
   
 //Scan Line 
   
 //Ring Scan Line 
 //return how many points in the half plane left to the line determined by P[Origin](origin) and P[j] 
 //NOT include points on the radial (P[Origin], P[st]), 
 //BUT may include points on the reverse radial (st from P[Origin], and the reverse direction), it depends 
 //ptmp is a copy of point set P 
 inline bool cmp(const sp &u, const sp &v) 
 {return u.a < v.a;} 
 void ringscan(int N, sp p[], int origin, int cnt[]) { 
     sp ptmp[MAXN]; 
     for (int i = 0; i < N; ++i) 
     { 
         ptmp[i] = p[i]; 
         ptmp[i].id = i; 
     } 
     swap(ptmp[origin], ptmp[N-1]); 
     for (int i = 0; i < N-1; ++i) 
         ptmp[i].a = atan2(ptmp[i].y-ptmp[N-1].y, ptmp[i].x-ptmp[N-1].x); 
     sort(ptmp, ptmp+N-1, cmp); 
     //NOT include points in the reverse radial 
     for (int st = 0, ed = 0; st < N-1; ++st) 
     { 
         if (ed == st) ed++; 
         while ((ed<st+N-1) && (sgn(dir(ptmp[N-1], ptmp[st], ptmp[ed%(N-1)]))>0)) ed++; 
         cnt[st] = ed-1-st; 
     } 
     //include points in the reverse radial 
     /* 
     for (int st = 0, ed = 0; st < N-1; ++st) 
     { 
         while ((ed<st+N-1) && (sgn(dir(ptmp[N-1], ptmp[st], ptmp[ed%(N-1)]))>=0)) ed++; 
         cnt[st] = ed-1-st; 
     } 
     */
 } 
   
 #endif

凸包(graham)

/* 
    Project: Biribiri Standard Code Library [BSCL] 
    Author: [BUPT]AkemiHomura 
    Category: Geometry 
    Title: Graham Scan 
    Version: 0.314 
    Date: 2011-1-31 
    Remark: Find the the convex hull of point set P 
    Tested Problems: POJ1113 
    Tag: geometry, convex hull, Graham Scan 
    Special Thanks: Amber 
 */
 /* 
    Input: 
        A set of points p[] 
    Output: 
        The convex hull ch[], and the number of the points in it 
 */
   
 #include <cmath> 
 #include <algorithm> 
 using namespace std; 
   
 const double INF = 1e9; 
 const double EPS = 1e-8; 
 const double PI = acos(-1.0); 
   
 inline int sgn(double d) { 
    if (fabs(d) < EPS) return 0; 
    return d>0 ? 1 : -1; 
 } 
   
 struct sp { 
    double x, y; 
    sp () {} 
    sp (double xx, double yy): x(xx), y(yy) {} 
 }; 
   
 inline sp operator- (const sp &u, const sp &v) 
 {return sp(u.x-v.x, u.y-v.y);} 
   
 double det(const sp &u, const sp &v) 
 {return u.x*v.y - v.x*u.y;} 
   
 double dir(const sp &p, const sp &u, const sp &v) 
 {return det(u-p, v-p);} 
   
 bool cmp(const sp &u, const sp &v) { 
    if (sgn(u.y-v.y)==0) return u.x>v.x; 
    return u.y>v.y; 
 } 
   
 //输入点数N，点集p，bool变量in表示是否包括三点共线中间点，默认为false，为true可能会退化 
 //返回凸包点数，凸包集ch 
 int graham(int N, sp p[], sp ch[], bool in = 0) { 
    const double e = in ? EPS : -EPS; 
    int i, j, k; 
    if (N < 3) 
    { 
        for (i = 0; i < N; ++i) 
            ch[i] = p[i]; 
        return N; 
    } 
   
    sort(p, p+N, cmp); 
    ch[0] = p[0]; 
    ch[1] = p[1]; 
    for (i = j = 2; i < N; ch[j++]=p[i++]) 
        while (j>1 && dir(ch[j-1], ch[j-2], p[i])>e) --j; 
    ch[k=j++] = p[N-2]; 
    for (i = N-3; i > 0; ch[j++]=p[i--]) 
        while (j>k && dir(ch[j-1], ch[j-2], p[i])>e) --j; 
    while (j>k && dir(ch[j-1], ch[j-2], ch[0])>e) --j; 
    return j; 
 }

圆交/并

#include <cmath> 
 #include <algorithm> 
 using namespace std; 
   
 const double PI = acos(-1.0); 
 const double EPS = 1e-8; 
   
 int sgn(double d) { 
    if (fabs(d)<EPS) return 0; 
    return d>0?1:-1; 
 } 
   
 struct sp { 
    double x, y; 
    double pa; 
    int cnt; 
    sp() {} 
    sp(double a, double b): x(a), y(b) {} 
    sp(double a, double b, double c, int d): x(a), y(b), pa(c), cnt(d) {} 
    bool operator<(const sp &rhs) const { 
        return pa<rhs.pa; 
    } 
    void read() {scanf("%lf%lf", &x, &y);} 
    void write() {printf("%lf %lf\n", x, y);} 
 }; 
   
 sp operator+(const sp &u, const sp &v) { 
    return sp(u.x+v.x, u.y+v.y); 
 } 
   
 sp operator-(const sp &u, const sp &v) { 
    return sp(u.x-v.x, u.y-v.y); 
 } 
   
 double det(const sp &u, const sp &v) { 
    return u.x*v.y-v.x*u.y; 
 } 
   
 double dir(const sp &p, const sp &u, const sp &v) { 
    return det(u-p, v-p); 
 } 
   
 double dis(const sp &u, const sp &v) { 
    double dx = u.x-v.x; 
    double dy = u.y-v.y; 
    return sqrt(dx*dx+dy*dy); 
 } 
   
 //计算两圆交点 
 //输入圆心坐标和半径 
 //返回两圆是否相交(相切不算) 
 //如果相交，交点返回在a和b(从a到b为u的交弧) 
 bool cirint(const sp &u, double ru, const sp &v, double rv, sp &a, sp &b) { 
    double d = dis(u, v); 
    if (sgn(d-(ru+rv))>=0 || sgn(d-fabs(ru-rv))<=0) return 0; 
    sp c = u-v; 
    double ca, sa, cb, sb, csum, ssum; 
   
    ca = c.x/d, sa = c.y/d; 
    cb = (rv*rv+d*d-ru*ru)/2/rv/d, sb = sqrt(1-cb*cb); 
    csum = ca*cb-sa*sb; 
    ssum = sa*cb+sb*ca; 
    a = sp(rv*csum, rv*ssum); 
    a = a+v; 
   
    sb = -sb; 
    csum = ca*cb-sa*sb; 
    ssum = sa*cb+sb*ca; 
    b = sp(rv*csum, rv*ssum); 
    b = b+v; 
   
    return 1; 
 } 
   
 sp e[222]; 
 int cover[111]; 
   
 //求圆并 
 //输入点数N，圆心数组p，半径数组r，答案数组s 
 //s[i]表示被至少i个圆覆盖的面积(最普通的圆并就是s[1]) 
 void circle_union(int N, int p[], double r[], double s[]) { 
    int i, j, k; 
    for (i = 0; i < N; ++i) 
        for (j = 0; j < N; ++j) { 
            double rd = r[i]-r[j]; 
            if (i!=j && sgn(rd)>0 && sgn(dis(p[i], p[j])-rd)<=0) 
                cover[j]++; 
        } 
    for (i = 0; i < N; ++i) { 
        int ecnt = 0; 
        e[ecnt++] = sp(p[i].x-r[i], p[i].y, -PI, 1); 
        e[ecnt++] = sp(p[i].x-r[i], p[i].y, PI, -1); 
        for (j = 0; j < N; ++j) { 
            if (j==i) continue; 
            if (cirint(p[i], r[i], p[j], r[j], a, b)) { 
                e[ecnt++] = sp(a.x, a.y, atan2(a.y-p[i].y, a.x-p[i].x), 1); 
                e[ecnt++] = sp(b.x, b.y, atan2(b.y-p[i].y, b.x-p[i].x), -1); 
                if (sgn(e[ecnt-2].pa-e[ecnt-1].pa)>0) { 
                    e[0].cnt++; 
                    e[1].cnt--; 
                } 
            } 
        } 
        sort(e, e+ecnt); 
        int cnt = e[0].cnt; 
        for (j = 1; j < ecnt; ++j) { 
            double pad = e[j].pa-e[j-1].pa; 
            s[cover[i]+cnt] += (det(e[j-1], e[j])+r[i]*r[i]*(pad-sin(pad)))/2; 
            cnt += e[j].cnt; 
        } 
    } 
 }

费马点(模拟退火) 

#include <cmath> 
 #include <algorithm> 
 using namespace std; 
   
 const double EPS = 1e-8; 
   
 struct sp { 
    double x, y; 
    sp () {} 
    sp (double xx, double yy): x(xx), y(yy) {} 
 }; 
   
 inline sp operator- (const sp &u, const sp &v) 
 {return sp(u.x-v.x, u.y-v.y);} 
   
 double nrmsqr(const sp &v) 
 {return v.x*v.x + v.y*v.y;} 
   
 double dis(const sp &u, const sp &v) { 
    double dx = u.x-v.x; 
    double dy = u.y-v.y; 
    return sqrt(dx*dx+dy*dy); 
 } 
   
 double fermatpoint(int N, sp p[]) { 
    sp u, v; 
    double step = 0; 
    u.x = u.y = 0; 
    for (int i = 0; i < N; ++i) 
    { 
        u.x += p[i].x; 
        u.y += p[i].y; 
    } 
    step = u.x+u.y; 
    u.x /= N; 
    u.y /= N; 
    double now, best = 0; 
    for (int i = 0; i < N; ++i) 
        best += dis(u, p[i]); 
    while (step > EPS) 
    { 
        for (int i = -2; i <= 2; ++i) 
            for (int j = -2; j <= 2; ++j) 
            { 
                v.x = u.x+step*i; 
                v.y = u.y+step*j; 
                now = 0; 
                for (int k = 0; k < N; ++k) 
                    now += dis(v, p[i]); 
                if (now < best) 
                { 
                    best = now; 
                    u = v; 
                } 
            } 
        //影响ac,wa,tle... 
        step /= 1.1; 
    } 
    return best; 
 }

凸多边形交 

#include <cmath> 
 #include <algorithm> 
 using namespace std; 
   
 const double EPS = 1e-8; 
   
 inline int sgn(double d) { 
    if (fabs(d) < EPS) return 0; 
    return d>0 ? 1: -1; 
 } 
   
 struct sp { 
    double x, y; 
    sp() {} 
    sp(double xx, double yy): x(xx), y(yy) {} 
 }; 
   
 inline sp operator- (const sp &u, const sp &v) 
 {return sp(u.x-v.x, u.y-v.y);} 
   
 inline bool operator== (const sp &u, const sp &v) 
 {return sgn(u.x-v.x)==0 && sgn(u.y-v.y)==0;} 
   
 struct ss { 
    sp a, b; 
    ss() {} 
    ss(sp u, sp v): a(u), b(v) {} 
 }; 
   
 double det(const sp &u, const sp &v) 
 {return u.x*v.y - v.x*u.y;} 
   
 double dir(const sp &p, const sp &u, const sp &v) 
 {return det(u-p, v-p);} 
   
 bool coline(const sp &p0, const sp &p1, const sp &p2) 
 {return sgn(dir(p0, p1, p2))==0;}   
   
 bool online(const sp &p, const ss &s) 
 {return coline(p, s.a, s.b);} 
   
 bool onseg(const sp &p, const ss &s) 
 {return online(p, s) && (s.a.x-p.x)*(s.b.x-p.x)<EPS && (s.a.y-p.y)*(s.b.y-p.y)<EPS;} 
   
 bool sameside(const sp &u, const sp &v, const ss &s) 
 {return dir(s.b, s.a, u)*dir(s.b, s.a, v)>EPS;} 
   
 bool segint(const ss &u, const ss &v) { 
    if (!coline(u.a, u.b, v.a) || !coline(u.a, u.b, v.b)) 
        return !sameside(u.a, u.b, v) && !sameside(v.a, v.b, u); 
    else
        return onseg(u.a, v) || onseg(u.b, v) || onseg(v.a, u) || onseg(v.b, u); 
 } 
   
 char lineintp(const ss &u, const ss &v, sp &p) { 
    double a1, b1, c1, a2, b2, c2; 
    a1 = u.b.y - u.a.y; 
    b1 = u.a.x - u.b.x; 
    c1 = det(u.b, u.a); 
    a2 = v.b.y - v.a.y; 
    b2 = v.a.x - v.b.x; 
    c2 = det(v.b, v.a); 
    if (sgn(a1*b2-b1*a2)==0) 
        if (sgn(det(u.a-v.a, u.a-v.b))==0) return 0; 
        else return 1; 
    else
    { 
        double t = a2*b1-a1*b2; 
        p.x = (b2*c1-b1*c2)/t; 
        p.y = (a1*c2-a2*c1)/t; 
        return 2; 
    } 
 } 
   
 int polycut(int N, sp p[], const ss &s, const sp &side, sp q[]) { 
    sp pp[111]; 
    int M = 0, res = 0, i; 
    for (i = 0; i < N; ++i) { 
        if (sameside(p[i], side, s)) 
            pp[M++] = p[i]; 
        if (!sameside(p[i], p[(i+1)%N], s) 
            && !(sgn(dir(s.b, p[i], s.a))==0 
            && sgn(dir(s.b, p[(i+1)%N], s.a))==0)) 
            lineintp(ss(p[i], p[(i+1)%N]), s, pp[M++]); 
    } 
    for (res = i = 0; i < M; ++i) { 
        if (!i || sgn(pp[i].x-pp[i-1].x)!=0 || sgn(pp[i].y-pp[i-1].y)!=0) 
            q[res++] = pp[i]; 
    } 
    if (sgn(q[res-1].x-q[0].x)==0 && sgn(q[res-1].y-q[0].y)==0) 
        res--; 
    if (res < 3) res = 0; 
    return res; 
 } 
   
 bool cmp(const sp &u, const sp &v) { 
    if (sgn(u.y-v.y)==0) return u.x>v.x; 
    return u.y>v.y; 
 } 
   
 int graham(int N, sp p[], sp ch[], bool in = 0) { 
    const double e = in ? EPS : -EPS; 
    int i, j, k; 
    if (N < 3) 
    { 
        for (i = 0; i < N; ++i) 
            ch[i] = p[i]; 
        return N; 
    } 
   
    sort(p, p+N, cmp); 
    ch[0] = p[0]; 
    ch[1] = p[1]; 
    for (i = j = 2; i < N; ch[j++]=p[i++]) 
        while (j>1 && dir(ch[j-1], ch[j-2], p[i])>e) --j; 
    ch[k=j++] = p[N-2]; 
    for (i = N-3; i > 0; ch[j++]=p[i--]) 
        while (j>k && dir(ch[j-1], ch[j-2], p[i])>e) --j; 
    while (j>k && dir(ch[j-1], ch[j-2], ch[0])>e) --j; 
    return j; 
 } 
   
 //凸多边形交 
 //输入两个多边形p和q（逆时针）及相应点数N和M 
 //返回两个多边形的交于r，返回点数 
 //graham为可选步骤，最好做一下保证正确性 
 int polyint(int N, sp p[], int M, sp q[], sp r[]) { 
    int i, j, k; 
    sp t[111]; 
    for (i = 0; i < N; ++i) 
        t[i] = p[i]; 
    int res = N; 
    for (i = 0; i < M; ++i) { 
        res = polycut(res, t, ss(q[i], q[(i+1)%M]), q[(i+2)%M], t); 
        if (res==0) return 0; 
    } 
    res = graham(res, t, r); 
    return res; 
}

给定半径圆覆盖

/* 
    Project: AkemiHomura's Standard Code Library [AHSCL] 
    Author: [BUPT]AkemiHomura@PuellaMagi 
    Category: Geometry 
    Title: Radius Circle Cover 
    Version: 0.103 
    Date: 2011-8-17 
    Remark: Given a point set P, find a circle with a given radius R that covers the most points in P 
    Tested Problems: Ural1332 
    Tag: Geometry 
    Special Thanks: Amber, eucho@PuellaMagi, mabodx@PuellaMagi 
 */
   
 #include <cstdio> 
 #include <cstring> 
 #include <cmath> 
 #include <algorithm> 
 using namespace std; 
   
 const double EPS = 1e-8; 
 const double PI = acos(-1.0); 
   
 inline int sgn(double d) { 
    if (fabs(d)<EPS) return 0; 
    return d>0?1:-1; 
 } 
   
 struct sp { 
    double x, y; 
    sp() {} 
    sp(double xx, double yy): x(xx), y(yy) {} 
    void read() {scanf("%lf%lf", &x, &y);} 
 }; 
   
 inline sp operator- (const sp &u, const sp &v) 
 {return sp(u.x-v.x, u.y-v.y);} 
   
   
 double dis(const sp &u, const sp &v) { 
    double dx = u.x-v.x; 
    double dy = u.y-v.y; 
    return sqrt(dx*dx+dy*dy); 
 } 
   
 double pa(const sp &p, const sp &p0) 
 {return atan2(p.y-p0.y, p.x-p0.x);} 
   
 struct sarc { 
    double a; 
    char cnt; 
    sarc() {} 
    sarc(double aa, int cc): a(aa), cnt(cc) {} 
 }; 
 bool operator< (const sarc &a1, const sarc &a2) { 
    //if (sgn(a1.a-a2.a)==0) return a1.cnt>a2.cnt; 
    return a1.a<a2.a; 
 } 
   
 //给定半径圆覆盖 
 //输入点集大小N，点集p，给定半径r 
 //返回能覆盖最多点的点数及圆心c 
 int rcc(int N, sp p[], double r, sp &c) { 
    if (sgn(r)<0) return 0; 
    c = p[0]; 
    if (sgn(r)==0) return 1; 
    sarc arc[1000]; 
    int arccnt, swpcnt, res = 1; 
    double d, a, da, as, ae; 
    for (int i = 0; i < N; ++i) { 
        swpcnt = arccnt = 0; 
        for (int j = 0; j < N; ++j) { 
            if (i==j) continue; 
            d = dis(p[i], p[j]); 
            if (sgn(d-r-r)>0) continue; 
            a = pa(p[j], p[i]); 
            da = acos(d/(2*r)); 
            if (sgn(da)==0) { 
                arc[arccnt++] = sarc(a, 1); 
                arc[arccnt++] = sarc(a, -1); 
                continue; 
            } 
            as = a-da; 
            ae = a+da; 
            if (sgn(as+PI)<0) as += 2*PI; 
            if (sgn(ae-PI)>0) ae += 2*PI; 
            if (sgn(as-ae)>0) { 
                arc[arccnt++] = sarc(as, 1); 
                arc[arccnt++] = sarc(PI, -1); 
                arc[arccnt++] = sarc(-PI, 1); 
                arc[arccnt++] = sarc(ae, -1); 
            } 
            else { 
                arc[arccnt++] = sarc(as, 1); 
                arc[arccnt++] = sarc(ae, -1); 
            } 
        } 
        sort(arc, arc+arccnt); 
        for (int j = 0; j < arccnt; ++j) { 
            swpcnt += arc[j].cnt; 
            if (swpcnt+1 > res) { 
                res = swpcnt+1; 
                c.x = p[i].x+r*cos(arc[j].a); 
                c.y = p[i].y+r*sin(arc[j].a); 
            } 
        } 
    } 
    return res; 
 }

最小覆盖圆

/* 
    Project: AkemiHomura's Standard Code Library [AHSCL] 
    Author: [BUPT]AkemiHomura@PuellaMagi 
    Category: Geometry 
    Title: Minimum Circle Cover 
    Version: 0.103 
    Date: 2011-5-3 
    Remark: Given a point set P, find the circle with minimum radius that covers all the points in P 
    Tested Problems: N/A 
    Tag: Geometry 
    Special Thanks: Amber, eucho@PuellaMagi, mabodx@PuellaMagi 
 */
   
 #include <cmath> 
 #include <algorithm> 
 using namespace std; 
   
 const double EPS = 1e-9; 
   
 inline int sgn(double d) { 
    if (fabs(d) < EPS) return 0; 
    return d>0?1:-1; 
 } 
   
 struct sp { 
    double x, y; 
    sp() {} 
    sp(double xx, double yy): x(xx), y(yy) {} 
 }; 
   
 inline sp operator- (const sp &u, const sp &v) 
 {return sp(u.x-v.x, u.y-v.y);} 
   
 double nrmsqr(const sp &v) 
 {return v.x*v.x+v.y*v.y;} 
   
 double dis(const sp &u, const sp &v) { 
    double dx = u.x-v.x; 
    double dy = u.y-v.y; 
    return sqrt(dx*dx+dy*dy); 
 } 
   
 double det(const sp &u, const sp &v) 
 {return u.x*v.y - v.x*u.y;} 
   
 double dir(const sp &p, const sp &u, const sp &v) 
 {return det(u-p, v-p);} 
   
 bool concylic(const sp &p1, const sp &p2, const sp &p3, sp &c, double r) { 
    if (sgn(dir(p1, p2, p3))==0) return 0; 
    double t1 = nrmsqr(p1)-nrmsqr(p2); 
    double t2 = nrmsqr(p1)-nrmsqr(p3); 
    double t3 = 2*(p1.x-p2.x)*(p1.y-p3.y)-2*(p1.x-p3.x)*(p1.y-p2.y); 
    c.x = ((p1.y-p3.y)*t1-(p1.y-p2.y)*t2)/t3; 
    c.y = -((p1.x-p3.x)*t1-(p1.x-p2.x)*t2)/t3; 
    r = dis(c, p1); 
    return 1; 
 } 
   
 //mcc:minimum circle cover 
 //最小圆覆盖 
 //输入点集大小N，点集p 
 //返回覆盖所有点的最小圆的圆心c，半径r 
 void mcc(int N, sp p[], sp &c, double &r) { 
    random_shuffle(p, p+N); 
    c = p[0]; r = 0; 
    for (int i = 1; i < N; ++i) 
    if (sgn(dis(p[i],c)-r)>0) 
    { 
        c = p[i]; r = 0; 
        for (int j = 0; j < i; ++j) 
        if (sgn(dis(p[j], c)-r)>0) 
        { 
            c.x = (p[i].x+p[j].x)/2; 
            c.y = (p[i].y+p[j].y)/2; 
            r = dis(p[j], c); 
            for (int k = 0; k < j; ++k) 
            if (sgn(dis(p[k], c)-r)>0) 
            { 
                concylic(p[i], p[j], p[k], c, r); 
                r = dis(p[i], c); 
            } 
        } 
    } 
 }

旋转卡壳

/* 
    Project: Biribiri Standard Code Library [BSCL] 
    Author: [BUPT]Biribiri 
    Category: Geometry 
    Title: Rotating Calipers 
    Version: 0.314 
    Date: 2011/2/6 
    Remark: N/A 
    Tested Problems: N/A 
    Tag: geometry, rotating calipers 
    Special Thanks: Amber 
 */
 /* 
    Input: 
        A convex hull by counterclockwise 
    Output: 
        The maximum distance of pairs of points 
 */
   
 #include <cstdio> 
 #include <cmath> 
 #include <algorithm> 
 using namespace std; 
   
 const double INF = 1e9; 
 const double EPS = 1e-8; 
 const double PI = acos(-1.0); 
   
 inline int sgn(double d) { 
    if (fabs(d) < EPS) return 0; 
    return d>0 ? 1 : -1; 
 } 
   
 struct sp { 
    double x, y; 
    double dis, ang; 
    sp() {} 
    sp(double xx, double yy): x(xx), y(yy) {} 
    void read() {scanf("%lf%lf", &x, &y);} 
 }; 
   
 sp operator - (const sp &v1, const sp &v2) 
 {return sp(v1.x-v2.x, v1.y-v2.y);} 
   
 double det(const sp &u, const sp &v) 
 {return u.x*v.y - v.x*u.y;} 
   
 double dis(const sp &u, const sp &v) { 
    double dx = u.x-v.x; 
    double dy = u.y-v.y; 
    return sqrt(dx*dx+dy*dy); 
 } 
   
 double dir(const sp &p, const sp &u, const sp &v) 
 {return det(u-p, v-p);} 
   
 double rotatingcalipers(int N, sp poly[]) { 
    poly[N] = poly[0]; 
    int p=0, q=1; 
    double ans = 0; 
    for (; p < N; ++p) { 
        //p, q即对踵点 
        //此处根据不同的需求改卡壳函数 
        while (sgn(dir(poly[p], poly[p+1], poly[q+1])-dir(poly[p], poly[p+1], poly[q])) > 0) 
            q = (q+1) % N; 
        ans = max(ans, max(dis(poly[p], poly[q]), dis(poly[p+1], poly[q+1]))); 
    } 
    return ans; 
 } 
   
 /* 
 begin 
      p0:=pn; 
      q:=NEXT[p]; 
      while (Area(p,NEXT[p],NEXT[q]) > Area(p,NEXT[p],q)) do 
           q:=NEXT[q]; 
           q0:=q; 
           while (q != p0) do 
                begin 
                     p:=NEXT[p]; 
                     Print(p,q); 
                     while (Area(p,NEXT[p],NEXT[q]) > Area(p,NEXT[p],q) do 
                          begin 
                               q:=NEXT[q]; 
                               if ((p,q) != (q0,p0)) then Print(p,q) 
                               else return 
                          end; 
                     if (Area(p,NEXT[p],NEXT[q]) = Area(p,NEXT[p],q)) then 
                       if ((p,q) != (q0,p0)) then Print(p,NEXT[q]) 
                       else Print(NEXT[p],q) 
                end 
 end. 
 */