LA 4728 (旋转卡壳) Squares

题意：

求平面上的最远点对距离的平方。

分析：

对于这个数据量枚举肯定是要超时的。

首先这两个点一定是在凸包上的，所以可以枚举凸包上的点，因为凸包上的点要比原来的点会少很多，可最坏情况下的时间复杂度也是O(n²).

于是就有了旋转卡壳。

可以想象有两条平行直线紧紧地夹住这个凸包，那直线上的点就是对踵点对。对踵点对最多有四对，就是当凸包的两边和两直线重合的情况。

直线的角度不断变化，直线上的对踵点对也会发生变化，当直线旋转过180°后，那么凸包上所有的对踵点对也就全部遍历到了。

代码中还有很详细的注释。

里面是利用比较△(u, u+1, v) 和 △(u, u+1, v+1)的面积大小来寻找对踵点对的。因为是凸多边形，所以面积的比较转化成了两个叉积的比较，最后化简成了一个叉积P_uP_u+1×P_vP_v+1。

直接从化简出来的结果来看，如果两个向量的叉乘大于0的话，说明v正在远离直线P_uP_u+1，如果小于0的话说明正在靠近直线，也很容易理解。

//#define LOCAL
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;

struct Point
{
    int x, y;
    Point(int x=0, int y=0):x(x), y(y){}
};
typedef Point Vector;

Point operator + (Point a, Point b) { return Point(a.x+b.x, a.y+b.y); }
Point operator - (Point a, Point b) { return Point(a.x-b.x, a.y-b.y); }
int Dot(Vector A, Vector B) { return A.x*B.x + A.y*B.y; }
int Cross(Vector A, Vector B) { return A.x*B.y - A.y*B.x; }

bool operator < (const Point& a, const Point& b)
{
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}

bool operator == (const Point& a, const Point& b)
{
    return a.x == b.x && a.y == b.x;
}

int Dist2(const Point& a, const Point& b)
{ return (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y); }

vector<Point> ConvexHull(vector<Point>& p)
{
    sort(p.begin(), p.end());
    p.erase(unique(p.begin(), p.end()), p.end());
    
    int n = p.size();
    int m = 0;
    vector<Point> ch(n+1);
    for(int i = 0; i < n; ++i)
    {
        while(m > 1 && 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-2; i >= 0; --i)
    {
        while(m > k && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) <= 0) m--;
        ch[m++] = p[i];
    }
    if(n > 1) m--;
    ch.resize(m);
    return ch;
}

int diameter2(vector<Point>& points)
{
    vector<Point> p = ConvexHull(points);
    int n = p.size();
    //for(int i = 0; i < n; ++i)    printf("%d %d
", p[i].x, p[i].y);
    if(n == 1)    return 0;
    if(n == 2)  return Dist2(p[0], p[1]);
    p.push_back(p[0]);
    int ans = 0;
    for(int u = 0, v = 1; u < n; ++u)
    {// 一条直线贴住边p[u]-p[u+1]
        while(true)
        {
            // 当Area(p[u], p[u+1], p[v+1]) <= Area(p[u], p[u+1], p[v])时停止旋转
            //因为两个三角形有一公共边，所以面积大的那个点到直线距离大 
            // 即Cross(p[u+1]-p[u], p[v+1]-p[u]) - Cross(p[u+1]-p[u], p[v]-p[u]) <= 0
            // 根据Cross(A,B) - Cross(A,C) = Cross(A,B-C)
            // 化简得Cross(p[u+1]-p[u], p[v+1]-p[v]) <= 0
            int diff = Cross(p[u+1]-p[u], p[v+1]-p[v]);
            if(diff <= 0)
            {
                ans = max(ans, Dist2(p[u], p[v]));
                if(diff == 0)    ans = max(ans, Dist2(p[u], p[v+1]));
                break;
            } 
            v = (v+1)%n;
        }
    }
    return ans;
}

int main(void)
{
    #ifdef LOCAL
        freopen("4728in.txt", "r", stdin);
    #endif
    
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int n, x, y, w;
        scanf("%d", &n);
        vector<Point> p;
        for(int i = 0; i < n; ++i)
        {
            scanf("%d%d%d", &x, &y, &w);
            p.push_back(Point(x, y));
            p.push_back(Point(x+w, y));
            p.push_back(Point(x+w, y+w));
            p.push_back(Point(x, y+w));
        }
        printf("%d
", diameter2(p));
    }

    return 0;
}