凸包 ACM

在二维欧几里得空间中，凸包可想象为一条刚好包著所有点的橡皮圈。
用不严谨的话来讲，给定二维平面上的点集，凸包就是将最外层的点连接起来构成的凸多边形，它能包含点集中所有的点。（以上摘自百度百科）
在ACM中，凸包是必不可少的知识点。下面我们来了解凸包。
建立凸包
1 选基点
在理论上，我们在 横坐标最小、横坐标最大，纵坐标最小、纵坐标最大的四个点当中选一个点即可（因为以其为顶点连接任意两个点，其角度不大于180，在后面用的上），在实际中我们往往选纵坐标最小的点，若多点纵坐标为最小值，再选其中横坐标为最小值的点。
2 点排序
将剩余的点与基点的连线（基点为起始点）按逆时针方向排序。
3 选凸包上的点
性质：如果两点都在凸包上，且后一个点在顺序上靠后，那么前一个点与后一个点的连线在后一点与任意点的连线的顺时针方向。
利用这个性质，按照排序点的顺序进行筛选即可。

while(top>0&&cross(list[stack[top-1]],list[stack[top]],list[i])<=0) top--;

在这里改动<=，决定凸包上三点共线，中间的点能不能进入凸包，<能进入，<=不能进入。

凸包模板：

#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int MAXN=1000;
const double PI=acos(-1.0);

struct point
{
    int x,y;
};
point list[MAXN];
int stack[MAXN],top;

int cross(point p0,point p1,point p2) //计算叉积  p0p1 X p0p2
{
    return (p1.x-p0.x)*(p2.y-p0.y)-(p1.y-p0.y)*(p2.x-p0.x);
}
bool cmp(point p1,point p2) //极角排序函数 ， 角度相同则距离小的在前面
{
    int tmp=cross(list[0],p1,p2);
    if(tmp>0) return true;
    else if(tmp==0&&dis(list[0],p1)<dis(list[0],p2)) return true;
    else return false;
}
void init(int n) //输入，并把  最左下方的点放在 list[0]  。并且进行极角排序
{
    int i,k;
    point p0;
    scanf("%d%d",&list[0].x,&list[0].y);
    p0.x=list[0].x;
    p0.y=list[0].y;
    k=0;
    for(i=1;i<n;i++)
    {
        scanf("%d%d",&list[i].x,&list[i].y);
        if( (p0.y<list[i].y) || ((p0.y==list[i].y)&&(p0.x>list[i].x)) )
        {
            p0.x=list[i].x;
            p0.y=list[i].y;
            k=i;
        }
    }
    list[k]=list[0];
    list[0]=p0;
    sort(list+1,list+n,cmp);
}

void graham(int n)
{
    int i;
    if(n==1) {top=0;stack[0]=0;}
    if(n==2)
    {
        top=1;
        stack[0]=0;
        stack[1]=1;
    }
    if(n>2)
    {
        for(i=0;i<=1;i++) stack[i]=i;
        top=1;

        for(i=2;i<n;i++)
        {
            while(top>0&&cross(list[stack[top-1]],list[stack[top]],list[i])<=0) top--;
            top++;
            stack[top]=i;
        }
    }
}

int main()
{
    int N,L;
    while(scanf("%d%d",&N,&L)!=EOF)
    {
        init(N);
        graham(N);
       

    }
    return 0;
}

模板来源于：https://www.cnblogs.com/kuangbin/archive/2012/04/13/2445633.html
真正的共线完整凸包

void graham(int n)
{
    int i;
    if(n==1) {top=0;stack[0]=0;}
    if(n==2)
    {
        top=1;
        stack[0]=0;
        stack[1]=1;
    }
    if(n>2)
    {
        for(i=0;i<=1;i++) stack[i]=i;
        top=1;

        for(i=2;i<n;i++)
        {
            while(top>0&&cross(list[stack[top-1]],list[stack[top]],list[i])<0) top--;
            top++;
            stack[top]=i;
        }
    }
   // printf("&&\n");
    for(int i=stack[top]-1;i>0;i--)
    {
        if(cross(list[0],list[stack[top]],list[i])==0)
         {

                        stack[++top]=i;
        }
    }
    //printf("%d\n",top);
}

旋转卡壳：
其实简单来说就是用一对平行线“卡”住凸包进行旋转。
被一对卡壳正好卡住的对应点对称为对踵点，对锺点的具体定义不好说，不过从图上还是比较好理解的。
可以证明对踵点的个数不超过3N/2个 也就是说对踵点的个数是O(N)的
对踵点的个数也是我们下面解决问题时间复杂度的保证。
卡壳呢，具体来说有两种情况：
1.

一种是这样，两个平行线正好卡着两个点；
2.

一种是这样，分别卡着一条边和一个点。
而第二种情况在实现中比较容易处理，这里就只研究第二种情况。

在第二种情况中 我们可以看到 一个对踵点和对应边之间的距离比其他点要大（借用某大神的图··）
也就是一个对踵点和对应边所形成的三角形是最大的 下面我们会据此得到对踵点的简化求法。

以上旋转卡壳介绍来自于 https://www.jianshu.com/p/74c25c0772d6
旋转卡壳的算法在于对踵点与边或点之间的距离是单峰函数（凸函数）