旋转卡壳->POJ2079

旋转卡壳：

推介blog：http://blog.youkuaiyun.com/hanchengxi/article/details/8639476
1.旋转卡壳求凸包直径：

如上图：

我们定起始点为A，首先从A点开始你顺时针找到凸包上距离A点最大距离的E点；

由于A到F的距离小于A到E的距离，此时我们旋转线的左端点到B点，再去计算B到F的距离，之后旋转线段的右端点，发现BG的距离小于BF，此继续旋转左端点到下一个顶点。

每次旋转卡壳的操作就是由一个固定的左端点，和旋转方向固定的右端点，求出其到一个右端点的距离函数由上升变为下降后，旋转左端点，继续计算距离，知道左端点再次回到A点的位置。

这样我们每次操作相当于得出了每个点到凸包上其他点的最大距离，要求所有顶点之间的最大距离，只需从这些所有的最大距离中取最大值即可。

---

例题：POJ2187

题意：

给出平面上n个点，求出这些点中距离最大的两个点。

题解：

构建一个凸包，通过旋转卡壳求凸包的直径。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
using namespace std;

struct Point
{
    int x,y;
    Point(int _x = 0, int _y = 0)
    {
        x = _x;
        y = _y;
    }
    Point operator -(const Point &b)const
    {
        return Point(x - b.x, y - b.y);
    }
    int operator ^(const Point &b)const
    {
        return x*b.y - y*b.x;
    }
    int operator *(const Point &b)const
    {
        return x*b.x + y*b.y;
    }
    void input()
    {
        scanf("%d%d",&x,&y);
    }
};
int dist2(Point a,Point b)
{
    return (a-b)*(a-b);
}
const int MAXN = 50010;
Point list[MAXN];
int Stack[MAXN],top;
bool _cmp(Point p1,Point p2)
{
    int tmp = (p1-list[0])^(p2-list[0]);
    if(tmp > 0)return true;
    else if(tmp == 0 && dist2(p1,list[0]) <= dist2(p2,list[0]))
        return true;
    else return false;
}
void Graham(int n)
{
    Point p0;
    int k = 0;
    p0 = list[0];
    for(int i = 1;i < n;i++)
        if(p0.y > list[i].y || (p0.y == list[i].y && p0.x > list[i].x))
        {
            p0 = list[i];
            k = i;
        }
    swap(list[0],list[k]);
    sort(list+1,list+n,_cmp);
    if(n == 1)
    {
        top = 1;
        Stack[0] = 0;
        return;
    }
    if(n == 2)
    {
        top = 2;
        Stack[0] = 0;
        Stack[1] = 1;
        return;
    }
    Stack[0] = 0;
    Stack[1] = 1;
    top = 2;
    for(int i = 2;i < n;i++)
    {
        while(top > 1 && ((list[Stack[top-1]]-list[Stack[top-2]])^(list[i]-list[Stack[top-2]])) <= 0 )
            top--;
        Stack[top++] = i;
    }
}
//旋转卡壳，求两点间距离平方的最大值
int rotating_calipers(Point p[],int n)
{
    int ans = 0;
    Point v;
    int cur = 1;
    for(int i = 0;i < n;i++)
    {
        v = p[i]-p[(i+1)%n];
        while((v^(p[(cur+1)%n]-p[cur])) < 0)
            cur = (cur+1)%n;
        //printf("%d %d\n",i,cur);
        ans = max(ans,max(dist2(p[i],p[cur]),dist2(p[(i+1)%n],p[(cur+1)%n])));
    }
    return ans;
}
Point p[MAXN];
int main()
{
    int n;
    while(scanf("%d",&n) == 1)
    {
        for(int i = 0;i < n;i++)
            list[i].input();
        Graham(n);
        for(int i = 0;i < top;i++)
            p[i] = list[Stack[i]];
        printf("%d\n",rotating_calipers(p,top));
    }
    return 0;
}

---

2.旋转卡壳求凸包的宽

求凸包的宽时，通过枚举每条边和顶点构成的三角形的最大面积的最小值实现。

如上图：
先选取AB边，然后通过计算三角形面积最大值的方式找到E点。

当发现顺时针旋转三角形顶点到F点后，三角形的面积值函数由上升变为下降，此时旋转底边到BC，继续求三角形面积。

每次通过枚举一条边，由三角形面积函数的增减性的改变可以求出以这条边为底边的三角形的最大面积是由哪个顶点构成的，记录此时三角形的高度。

对于所有边的面积最大三角形的高度的最小值就是凸包的宽。

---

例题：POJ2079

题意：

给出平面上一些点，求任选三个点，这些点能构成的三角形的面积最大值。

题解：

构建凸包，在旋转卡壳求凸包的宽度时记录最大值，即可计算得出答案。

代码：

#include <stdio.h>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <float.h>
using namespace std ;
#define MAX 50005
struct Point
{
    int x , y ;
    Point(){}
    Point(int _x , int _y)
    {
        x = _x ; y = _y ;
    }
    Point operator - (const Point &b) const
    {
        return Point(x - b.x , y - b.y) ;
    }
    int operator ^ (const Point &b) const
    {
        return x*b.y - y*b.x ;
    }
    int operator * (const Point &b) const
    {
        return x*b.x + y*b.y ;
    }
};
struct Line
{
    Point s , e ;
    Line(){}
    Line(Point _s , Point _e)
    {
        s = _s ; e = _e ;
    }
};
int xmult(Point p0,Point p1,Point p2) //叉积p0p1 X p0p2
{
    return (p1-p0)^(p2-p0);
}
int dist2(Point a,Point b)
{
    return (a-b)*(a-b);
}
Point list[MAX] ;
int Stack[MAX] , top ;
bool _cmp(Point p1,Point p2)
{
    int tmp = (p1-list[0])^(p2-list[0]);
    if(tmp > 0)return true;
    else if(tmp == 0 && dist2(p1,list[0]) <= dist2(p2,list[0]))
        return true;
    else return false;
}
void anglesort(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)
{
    Point p0;
    int k = 0;
    p0 = list[0];
    //找最下边的一个点
    for(int i = 1;i < n;i++)
    {
        if( (p0.y > list[i].y) || (p0.y == list[i].y && p0.x > list[i].x) )
        {
            p0 = list[i];
            k = i;
        }
    }
    swap(list[k],list[0]);
    sort(list+1,list+n,_cmp);
    if(n == 1)
    {
        top = 1;
        Stack[0] = 0;
        return;
    }
    if(n == 2)
    {
        top = 2;
        Stack[0] = 0;
        Stack[1] = 1;
        return ;
    }
    Stack[0] = 0;
    Stack[1] = 1;
    top = 2;
    for(int i = 2;i < n;i++)
    {
        while(top > 1 && ((list[Stack[top-1]]-list[Stack[top-2]])^(list[i]-list[Stack[top-2]])) <= 0 )
            top--;
        Stack[top++] = i;
    }
}
int rotating_calipers(Point p[],int n)
{
    int ans = 0;
    Point v;
    int cur = 1;
    for(int i = 0;i < n;i++)
    {
        int j = (i+1)%n;
        int k = (j+1)%n;
        while(j != i && k != i)
        {
            ans = max(ans,abs((p[j]-p[i])^(p[k]-p[i])) );
            while( ( (p[i]-p[j])^(p[(k+1)%n]-p[k]) ) < 0 )
                k = (k+1)%n;
            j = (j+1)%n;
        }
    }
    return ans;
}
Point now[MAX] ;
int main()
{
    int n ;
    while(scanf("%d" , &n)!=EOF&&n>0)
    {
        anglesort(n) ;
        Graham(n) ;
        for(int i = 0 ; i< top ; i++)
            now[i] = list[Stack[i]] ;
        printf("%.2f\n", rotating_calipers(now,top)/2.0);
    }
    return 0;
}