【总结】半平面交

问题概述：

所谓半平面交，其实和高中数学中的线性规划有些类似：
在一个平面中，给出n条线，每条线必然会将平面分割成两个部分，现在我们规定这条线是有向的，将这条线的左部分区域作为选中的区域。最后求能被所有线选中的区域。

这个问题经常与另一种问题挂钩：求一个多边形的内核，内核是一种点集，在内核中的点到边上任意一点的连线必然处于多边形内部。一个常用且形象的比喻：将多边形比作一个房间，在内核中任意一点安装一个摄像头，可以不被阻挡地监视整个房间。

乍一看可能并不觉得这两个问题有什么关联。但其实两个问题是几乎等价的：在多边形中，每条边均有一侧是多边形内部，而另一侧则是外部，很显然，如果要能满足内核的定义，那么这个内核一定处于该边向多边形内部的一侧。
如图中的绿色部分：

该区域满足处于所有边的内部，同时这个区域也正是多边形的内核。

算法介绍

这是从LRJ书上所学的，比较简单易懂的$O(nlogn)$算法（增量法）

初始状态答案为整个平面，然后逐一加入各个半平面，维护当前的半平面交。

维护半平面交的方法很简单：通过各条线的交点来维护。
我们按照斜率，将直线排序，从小到大的顺序依次考虑每一条直线。
通过一个双端队列，将各条已处理的直线的交点存储下来，每次加入一条新的直线，就从队首以及队尾依次删去在直线右边的点。由于我们维护的是一个类似于凸壳的多边型，所以不会遇到队中有点位于直线右侧，但队首队尾却在直线左侧的情况。

具体实现过程非常类似于之前学DP时用到的斜率优化。
模板题：POJ3130 判断是否存在内核

#include
#include
#include
#include
#define SF scanf
#define PF printf
#define MAXN 1010
using namespace std;
const double eps=1e-7;
struct Point{
    double x,y;
    Point() {}
    Point(double xx,double yy):x(xx),y(yy) {}
}p[MAXN],a[MAXN];
typedef Point Vector;
struct Line{
    Point P;
    Vector v;
    double ang;
    Line() {}
    Line(Point P,Vector v):P(P),v(v){
        ang=atan2(v.y,v.x);
    }
    bool operator < (const Line & L)const {
        return ang<L.ang;
    }
}L[MAXN],poly[MAXN],q[MAXN];
Point operator + (Vector A,Vector B){return Point(A.x+B.x,A.y+B.y);}
Point operator - (Vector A,Vector B){return Point(A.x-B.x,A.y-B.y);}
Point operator * (Vector A,double p){return Point(A.x*p,A.y*p);}
Point operator / (Vector A,double p){return Point(A.x/p,A.y/p);}
bool operator < (Vector a,Vector b){return a.x<b.x||(fabs(a.x-b.x)<eps&&a.y<b.y);}
double Cross(Vector A,Vector B){return A.x*B.y-A.y*B.x;}
bool Onleft(Line L,Point p){
    return Cross(L.v,p-L.P)>0;
}
Point GetInt(Line a,Line b){
    Vector u=a.P-b.P;
    double t=Cross(b.v,u)/Cross(a.v,b.v);
    return a.P+a.v*t;
}
int n;
bool HalfplaneInt(){
    sort(L,L+n);
    int first=0,last=0;
    q[first]=L[0];
    for(int i=1;i<n;i++){
        while(first<last&&Onleft(L[i],p[last-1])==0) last--;
        while(first<last&&Onleft(L[i],p[first])==0) first++;
        q[++last]=L[i];
        if(fabs(Cross(q[last].v,q[last-1].v))<eps){
            last--;
            if(Onleft(q[last],L[i].P))
                q[last]=L[i];
        }
        if(first<last)
            p[last-1]=GetInt(q[last-1],q[last]);
    }
    while(first<last&&Onleft(q[first],p[last-1])==0) last--;
    if(last-first<=1)
        return 0;
    return 1;
}
int main(){
    SF("%d",&n);
    while(n){
        for(int i=0;i<n;i++)
            SF("%lf%lf",&a[i].x,&a[i].y);
        L[0]=Line(a[n-1],a[0]-a[n-1]);
        for(int i=1;i<n;i++)
            L[i]=Line(a[i],a[i]-a[i-1]);
        PF("%d\n",HalfplaneInt());
        SF("%d",&n);
    }
}

但这个算法并没有达到半平面交算法的最高效率，之后将补充半平面交的$O(nlogn)$算法
不好意思这就是O(nlogn)算法。。。。