凸包与旋转卡壳

关于凸包的几个名词：

1.支撑线：

如果一条直接L通过凸多边形P的一个顶点，且多边形在这条直线的一侧，则称L是P的支撑线

2.对踵点：

如果过凸包上的两个点可以画一对平行线，使得凸包上左右的点都夹在两条平行线之间或者

    落在平行线上那么两个点称为一对对踵点。两条平行的支撑线所过的两点就是一对对踵点。可以

    证明一个凸n边形的对踵点最多有3n/2对

3.凸多边形的直径：

将一个多边形上任意两点间的距离的最大值定义为多边形的直径。确定这个直径的点对数可能

    多于一对。

旋转卡壳求直径的步骤：

step1. 计算多边形y方向上的端点，ymin,ymax.

step2. 通过ymin,ymax,狗找两条水平的切线，由于它们已经是一对对踵点，计算它们之间的距

    离 并维护一个当前的最大值。

step3. 同时旋转两条之间到其中一条于多边形的一条边重合。

step4. 一个新的对踵点产生，计算新的距离，并和当前的最大值做比较，若大于当前最大值则

    更新。

step5. 重复操作3，4知道产生对踵点对(ymin,ymax).

分析：旋转卡壳的复杂度为O(n),求凸包的复杂度为O(nlogn).

题目链接：传送门 

求凸包的直径的平方

代码如下：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 5e4+10;

typedef struct Point{
    int x,y;
    bool operator <(const struct Point &B)const{
        if(x==B.x)  return y<B.y;
        return x<B.x;
    }
    bool operator ==(const struct Point &B)const{
        return (x-B.x)==0&&(y-B.y)==0;
    }
}Vector;

Vector p[maxn],st[maxn];

int Cross(Point a,Point b,Point o)        {
    return (a.x - o.x) * (b.y - o.y) - (b.x - o.x) * (a.y - o.y);
}

int ConvexHull(Point *p,int n,Point *st){
    sort(p,p+n);
    n = unique(p,p+n)-p;
    int m=0;
    for(int i=0;i<n;i++){
        while(m>1&&Cross(st[m-1],p[i],st[m-2])<=0) m--;
        st[m++]=p[i];
    }
    int k=m;
    for(int i=n-2;i>=0;i--){1
        while(m>k&&Cross(st[m-1],p[i],st[m-2])<=0) m--;
        st[m++]=p[i];
    }
    if(n>1) m--;
    return m;
}

int dis(Point a,Point b){
    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
}
//旋转卡壳求凸包的宽度
double rotating_calipers(Point *p,int n){
    int k = 1;
    double ans = 0x7FFFFFFF;
    p[n] = p[0];
    for(int i=0;i<n;i++){
        while(fabs(cross(p[i],p[i+1],p[k])) < fabs(cross(p[i],p[i+1],p[k+1])))
             k = (k+1) % n;
        double tmp = fabs(cross(p[i],p[i+1],p[k]));
        double d   = dist(p[i],p[i+1]);
        ans = min(ans,tmp/d);
    }
    return ans;
}
int main()
{
    int n;
    while(~scanf("%d",&n)){
        for(int i=0;i<n;i++){
            scanf("%d%d",&p[i].x,&p[i].y);
        }
        int m = ConvexHull(p,n,st);
        int ans = rotatint_calipers(st,m);
        printf("%d\n",ans);
    }
    return 0;
}

题目链接： 传送门 

题意：

平面上n个点，求从这n个点所能组成的最大的三角形的面积。

分析：

首先求凸包。最大的三角形的顶点一定在凸包上，枚举顶点i,j,k,j=i+1,k=j+1. 很明显

    在枚举k的时候我们可以固定i,j这两个点，然后找到当前能组成的最大的面积的点k.,而且k

    的变化和j有关，因此不用从头开始枚举。

        我们循环执行k+1,知道area(i,j,k+1)<area(i,j,k),这个时候更新最大的面积，然后可以

    旋转 j,k，如果area(i,j,k)<area(i,j,k+1) k!=i,则k++,否则跳出，更新面积,j++,旋转一周可

    以得到最大的三角形面积，时间复杂度O(n^2)

代码如下：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;

const int maxn = 5e4+10;

const double eps = 1e-10;

int dcmp(double x){
    if(fabs(x)<=0) return 0;
    if(x>0) return 1;
    else return -1;
}

typedef struct Point{
    double x,y;
    bool operator <(const struct Point &B)const{
        if(x==B.x)  return y<B.y;
        return x<B.x;
    }
    bool operator ==(const struct Point &B)const{
        return dcmp(x-B.x)==0&&dcmp(y-B.y)==0;
    }
}Vector;

Vector p[maxn],st[maxn];

double Cross(Point a,Point b,Point o)        {
    return (a.x - o.x) * (b.y - o.y) - (b.x - o.x) * (a.y - o.y);
}

int ConvexHull(Point *p,int n,Point *st){
    sort(p,p+n);
    n = unique(p,p+n)-p;
    int m=0;
    for(int i=0;i<n;i++){
        while(m>1&&Cross(st[m-1],p[i],st[m-2])<=0) m--;
        st[m++]=p[i];
    }
    int k=m;
    for(int i=n-2;i>=0;i--){
        while(m>k&&Cross(st[m-1],p[i],st[m-2])<=0) m--;
        st[m++]=p[i];
    }
    if(n>1) m--;
    return m;
}

double dis(Point a,Point b){
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}

double rotating_calipers(Point *p,int n){
    double ans = 0;
    int j,k;
    for(int i=0;i<n;i++){
        j=(i+1)%n;
        k=(j+1)%n;
        while(fabs(Cross(p[i+1],p[k],p[i]))<fabs(Cross(p[i+1],p[k+1],p[i])))
            k=(k+1)%n;
        while(j!=i&&k!=i){
            ans=max(ans,fabs(Cross(p[i],p[k],p[j])));
            while(fabs(Cross(p[i],p[k],p[j]))<fabs(Cross(p[i],p[(k+1)%n],p[j])))
                k=(k+1)%n;
            j=(j+1)%n;
        }
    }
    return ans/2.0;
}

int main()
{
    int n;
    while(~scanf("%d",&n)){
        if(n==-1) break;
        for(int i=0;i<n;i++)
            scanf("%lf%lf",&p[i].x,&p[i].y);
        int m = ConvexHull(p,n,st);
        //cout<<"m "<<m<<endl;
        if(m<3) puts("0.00");
        if(m==3) printf("%.2lf\n",fabs(Cross(st[0],st[1],st[2]))/2.0);
        else{
            double ans = rotating_calipers(st,m);
            printf("%.2lf\n",ans);
        }
    }
    return 0;
}