POJ 2187 Beauty Contest 旋转卡壳

题目大意：求平面最远点对。

思路：我会说正解是求出凸包之后暴力？然后我闲的蛋疼去写了旋转卡壳。。

还在写极角序扫描法的不要再写了。。。赶紧换水平序吧。。。因为极角序需要解决两个特别不科学的问题。

问题1：第一次排序的时候极角相同的情况，这个时候要保留最外面的。

问题2：在最后得到的凸包上有三点共线的情况。有的时候并不会影响答案，但是有的时候就会，比如说旋转卡壳的时候。我的解决方法是得到凸包之后再扫一遍，吧共线的点去掉。

然而如果用水平序，这两个问题都不是问题。没有极角排序，所以不会存在问题1，问题2只需要在维护栈的时候加一个等号就行了。。

这个题数据中有重点要注意判一下。

剩下就是裸的旋转卡壳了。其实不难理解。对于凸多边形上的每一条边，设这条线段为AB，用AB向所有其他的点做三角形，会发现能够更新最终平面最远点对的只有面积最大的那个三角形。如果按照顺时针的方向对每一条边进行枚举的话，那么最大面积的三角形的顶点也是顺时针的。也就是说O(n)扫一遍就可以出解，十分科学。

CODE：

#define _CRT_SECURE_NO_DEPRECATE

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAX 50010
#define INF 0x3f3f3f3f
#define EPS 1e-10
using namespace std;

struct Point{
	int x,y;
	double alpha;

	Point(int _,int __):x(_),y(__) {}
	Point() {}
	bool operator <(const Point &a)const {
		if(fabs(alpha - a.alpha) < EPS) {
			if(y == a.y)
				return x < a.x;
			return y < a.y;
		}
		return alpha < a.alpha;
	}
	Point operator +(const Point &a)const {
		return Point(x + a.x,y + a.y);
	}
	Point operator -(const Point &a)const {
		return Point(x - a.x,y - a.y);
	}
	void Read() {
		scanf("%d%d",&x,&y);
	}
}point[MAX],stack[MAX];

int cnt,points,top;

inline int Cross(const Point &p1,const Point &p2)
{
	return p1.x * p2.y - p2.x * p1.y;
}

inline int Calc(const Point &p1,const Point &p2)
{
	return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}

int RotatingCalipers(int top,Point stack[])
{
	int re = 0,now = 1;
	stack[top] = stack[0];
	for(int i = 0; i < top; ++i) {
		while(Cross(stack[i + 1] - stack[i],stack[now + 1] - stack[i]) > Cross(stack[i + 1] - stack[i],stack[now] - stack[i]))
			now = (now + 1) % top;
		re = max(re,Calc(stack[now],stack[i]));
		re = max(re,Calc(stack[now + 1],stack[i + 1]));
	}
	return re;
}

set<pair<int,int> > G;

int main()
{
	cin >> cnt;
	for(int x,y,i = 1; i <= cnt; ++i) {
		scanf("%d%d",&x,&y);
		if(G.find(make_pair(x,y)) != G.end())
			continue;
		G.insert(make_pair(x,y));
		point[++points] = Point(x,y);
	}
	int min_x = INF,min_y = INF,p;
	for(int i = 1; i <= points; ++i) {
		if(point[i].y < min_y)
			min_y = point[i].y,min_x = point[i].x,p = i;
		else if(point[i].y == min_y && point[i].x < min_x)
			min_x = point[i].x,p = i;
	}
	for(int i = 1; i <= points; ++i)
		if(i != p)
			point[i].alpha = atan2((double)point[i].y - min_y,(double)point[i].x - min_x);
		else	point[i].alpha = -INF;
	sort(point + 1,point + points + 1);
	stack[top] = point[1];
	stack[++top] = point[2];
	if(points >= 3)	stack[++top] = point[3];
	for(int i = 4; i <= points; ++i) {
		while(top >= 2 && Cross(point[i] - stack[top - 1],stack[top] - stack[top - 1]) > 0)
			--top;
		stack[++top] = point[i];
	}
	static Point temp[MAX];
	int total = top;
	top = 0;
	temp[top] = stack[0];
	for(int i = 1; i < total; ++i)
		if(Cross(stack[i] - temp[top],stack[i + 1] - temp[top]))
			temp[++top] = stack[i];
	temp[++top] = stack[total];
	cout << RotatingCalipers(top + 1,temp) << endl;
	return 0;
}