凸包

凸包就是把给定点包围在内部，面积最小的凸多边形

Graham扫描法

1.把点按照x坐标排序

2.将p1,p2放到凸包中

3.从p3开始，当新的点在凸包的前进方向的左边时加入该点，否则弹出最后加入的点，直到新点在左边

4.将上述流程反过来做一遍求上凸壳

 

struct vector
{
   double x,y;
   vector (double X=0,double Y=0)
   {
       x=X,y=Y;
    }
}
typedef vector point;
double cross(vector a,vector b)
{
    return a.x*b.y-a.y*b.x;
}


void convexhull(point *p,int n,point *ch)  
{  
    sort(p+1,p+n+1);  
    if (n==1){  
        ch[++m]=n;  
        return ;  
    }  
    m=1;  
    for (int i=1;i<=n;i++){  
        while (m>2&&dcmp(cross(ch[m-1]-ch[m-2],p[i]-ch[m-2]))<=0) m--;  
        ch[m++]=p[i];  
    }  
    int k=m;  
    for (int i=n-1;i>=1;i--){  
        while (m>k&&dcmp(cross(ch[m-1]-ch[m-2],p[i]-ch[m-2]))<=0) m--;  
        ch[m++]=p[i];  
    }  
    m--;  
}  

旋转卡壳

求凸包上最远点对的距离

被凸包上一对平行直线卡住的点对叫做对踵点，答案一定在对踵点上。
按照逆时针顺序枚举凸包上一条边，则凸包上到该边所在直线最远的点也单调逆时针旋转，相当于用一条直线卡对面一个顶点

double rotating_calipers(point* ch,int n)//旋转卡壳，被凸包上被一对平行直线卡住的点叫对踵点，最远点对一定在凸包的一对对踵点上  
{  
    if (n==1)  return 0;  
    if (n==2)  return dot(ch[0]-ch[1],ch[0]-ch[1]);//如果只有两个点，那么就是两点的直线距离  
    int now=1,i;  
    double ans=0;  
    ch[n]=ch[0];  
    for (int i=0;i<n;i++)  
    {  
        while(dcmp(distl(ch[now],ch[i],ch[i+1])-distl(ch[now+1],ch[i],ch[i+1]))<=0)//最远点随着平行线的旋转是单调的，所以点不会来回移动  
          now=(now+1)%n;  
        ans=max(ans,dot(ch[now]-ch[i],ch[now]-ch[i]));  
        ans=max(ans,dot(ch[now]-ch[i+1],ch[now]-ch[i+1]));//找到与当前直线平行的最远点，用来更新答案  
    }  
    return ans;  
}  

求两凸包上的最近距离

double rotating_calipers(point* p,point* q,int n,int m)//利用旋转卡壳求两个凸包上最近点的距离，一个凸包上的平行线逆时针旋转，另一个凸包上的最远点也单调逆时针旋转，所以这个算法要正反进行两遍  
{  
    int x=0; int y=0,i;  
    double ans=1e10,t;  
    for (int i=0;i<n;i++)  
     x=(p[i].y<p[x].y)?i:x;  
    for (int i=0;i<m;i++)  
     y=(p[i].y>p[y].y)?i:y;  
    p[n]=p[0]; q[m]=q[0];  
    for (int i=0;i<n;i++)  
    {  
        while((t=dcmp(cross(p[x]-p[x+1],q[y+1]-q[y])))<0)//判断凸壳上下一条边的旋转方向  
          y=(y+1)%m;  
        if (t==0)//平行的时候四个点之间更新答案  
        {  
            ans=min(ans,dists(p[x],q[y+1],q[y]));  
            ans=min(ans,dists(p[x+1],q[y+1],q[y]));  
            ans=min(ans,dists(q[y],p[x],p[x+1]));  
            ans=min(ans,dists(q[y+1],p[x],p[x+1]));  
        }  
        else  
          ans=min(ans,dists(q[y],p[x],p[x+1]));//否则只用最远点更新答案  
        x=(x+1)%n;  
    }  
    return ans;  
}  

最小圆覆盖

用最小的圆覆盖平面中的所有点。

point center(point a,point b,point c){  
    point p=(a+b)/2; point q=(a+c)/2;  
    vector v=rotate(b-a,pi/2); vector u=rotate(c-a,pi/2);  
    if (dcmp(cross(v,u))==0) {  
        if(dcmp(len(a-b)+len(b-c)-len(a-c))==0)  
            return (a+c)/2;  
        if(dcmp(len(a-c)+len(b-c)-len(a-b))==0)  
            return (a+b)/2;  
        if(dcmp(len(a-b)+len(a-c)-len(b-c))==0)  
            return (b+c)/2;  
    }  
    return glt(p,v,q,u);  
}  
double mincc(point *p,int n,point &c)  
{  
    random_shuffle(p,p+n);  
    c=p[0];  
    double  r=0;  
    int i,j,k;  
    for (i=1;i<n;i++)  
    if (dcmp(len(c-p[i])-r)>0){  
        c=p[i],r=0;  
        for (j=0;j<i;j++)  
        if (dcmp(len(c-p[j])-r)>0){  
            c=(p[i]+p[j])/2;  
            r=len(c-p[i]);  
            for (k=0;k<j;k++)  
            if (dcmp(len(c-p[k])-r)>0){   
              c=center(p[i],p[j],p[k]);  
              r=len(c-p[i]);  
            }  
        }  
    }  
    return r;  
}