Find the Border UVALive - 3218（PSGL）

Find the Border

 UVALive - 3218 

PSGL

#include <bits/stdc++.h>
using namespace std;
#define pb push_back
const double eps = 1e-8;
const int inf = 0x3f3f3f3f;

int dcmp(double x) {
    if(fabs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}

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

Vector operator + (Vector a, Vector  b) {
    return Vector(a.x+b.x, a.y+b.y);
}
Vector operator - (Point a, Point b) {
    return Vector(a.x-b.x, a.y-b.y);
}
Vector operator * (Vector a, double p) {
    return Vector(a.x*p, a.y*p);
}
Vector operator / (Vector a, double p) {
    return Vector(a.x/p, a.y/p);
}
// 理论上这个“小于”运算符是错的，因为可能有三个点a, b, c, a和b很接近（即a<b好b<a都不成立），b和c很接近，但a和c不接近
// 所以使用这种“小于”运算符的前提是能排除上述情况
bool operator < (Point a, Point b) {
    return dcmp(a.x-b.x)<0 || (dcmp(a.x-b.x)==0&&dcmp(a.y-b.y)<0);
}
bool operator == (Point a, Point b) {
    return dcmp(a.x-b.x)==0 && dcmp(a.y-b.y)==0;
}
double Dot(Vector a, Vector b) {
    return a.x*b.x + a.y*b.y;
}
double Cross(Vector a, Vector b) {
    return a.x*b.y - a.y*b.x;
}
double Length(Vector a) {
    return sqrt(Dot(a,a));
}

typedef vector<Point> Poly;

bool SegProIn(Point a1, Point b1, Point a2, Point b2) {
    double c1 = Cross(b1-a1, b2-a1), c2 = Cross(b1-a1,a2-a1);
    double c3 = Cross(b2-a2, a1-a2), c4 = Cross(b2-a2, b1-a2);
    return dcmp(c1)*dcmp(c2)<0 && dcmp(c3)*dcmp(c4)<0;
}
Point GetLineIn(Point p, Vector v, Point q, Vector w) {
    Vector u = p-q;
    double t = Cross(w,u) / Cross(v,w);
    return p+v*t;
}
bool OnSeg(Point p, Point a, Point b) {
    return dcmp(Cross(a-p, b-p))==0 && dcmp(Dot(a-p, b-p))<0;
}
// 多边形的有向面积
double GetArea(Poly p) {
    double area = 0;
    int n = p.size();
    for(int i = 1; i < n-1; i++) area += Cross(p[i]-p[0], p[(i+1)%n]-p[0]);
    return area/2;
}

struct Edge{
    int u, v;
    double ang;
    Edge(int u=0, int v=0, double ang=0): u(u), v(v), ang(ang){}
};
const int maxe = 10000+10;  // 最大边数

// 平面直线图（PSGL）实现
struct PSGL{
    int n, m, face_cnt;
    double x[maxe], y[maxe];
    vector<Edge> edges;
    vector<int> G[maxe];
    int vis[maxe<<1];  // 每条边是否已经访问过
    int left[maxe<<1];  // 左面的编号
    int pre[maxe<<1];  // 相同起点的上一条边（即顺时针旋转碰到的下一条边）的编号

    vector<Poly> faces;
    double area[maxe];

    void init(int n) {
        this->n = n;
        for(int i = 0; i < n; i++) G[i].clear();
        edges.clear();
        faces.clear();
    }
    double getAngle(int u,int v) {
        return atan2(y[v]-y[u], x[v]-x[u]);
    }
    void add(int u, int v) {
        edges.pb(Edge(u,v,getAngle(u,v)));
        edges.pb(Edge(v,u,getAngle(v,u)));
        m = edges.size();
        G[u].pb(m-2);
        G[v].pb(m-1);
    }
    //找出faces并计算面积
    void build(){
        for(int  u = 0; u < n; u++) {
            int d = G[u].size();
            for(int i = 0; i < d; i++) {
                for(int j = i+1; j < d; j++) {
                    if(edges[G[u][i]].ang > edges[G[u][j]].ang) swap(G[u][i],G[u][j]);
                }
            }
            for(int i = 0; i < d; i++) pre[G[u][(i+1)%d]] = G[u][i];
        }
        memset(vis, 0, sizeof(vis));
        face_cnt = 0;
        for(int u = 0; u < n; u++) {
            for(int i = 0; i < G[u].size(); i++){
                int e = G[u][i];
                if(!vis[e]){  //逆时针找圈
                    face_cnt++;
                    Poly p;
                    while(1){
                        vis[e] = 1;
                        left[e] = face_cnt;
                        int from = edges[e].u;
                        p.pb(Point(x[from], y[from]));
                        e = pre[e^1];
                        if(e == G[u][i]) break;
                    }
                    faces.pb(p);
                }
            }
        }
        for(int i = 0; i < faces.size(); i++) {
            area[i] = GetArea(faces[i]);

        }
    }

};

PSGL g;

const int maxv = 110;
int n, c;

Point p[maxv];
Point V[maxv*maxv/2+maxv];

int ID(Point p) {
    return lower_bound(V, V+c, p) - V;
}
//假定poly没有相邻点重合的情况，只需要删除三点共线的情况
Poly simplify(const Poly& p) {
    Poly temp;
    int n = p.size();
    for(int i = 0; i < n; i++) {
        Point a = p[i];
        Point b = p[(i+1)%n];
        Point c = p[(i+2)%n];
        if(dcmp(Cross(a-b, c-b)) != 0) temp.pb(b);
    }
    return temp;
}

void build_graph(){
    c = n;
    for(int i = 0; i < n; i++) V[i] = p[i];
    vector<double> dis[maxv];    // dist[i][j]是第i条线段上的第j个点离起点（P[i]）的距离
    for(int i = 0; i < n; i++) {
        for(int j = i+1; j < n; j++) {
            if(SegProIn(p[i], p[(i+1)%n], p[j], p[(j+1)%n])) {
                Point xy = GetLineIn(p[i], p[(i+1)%n]-p[i], p[j], p[(j+1)%n]-p[j]);
                V[c++] = xy;
                dis[i].pb(Length(xy - p[i]));
                dis[j].pb(Length(xy - p[j]));
            }
        }
    }
    // 为了保证“很接近的点”被看作同一个，这里使用了sort+unique的方法
  // 必须使用前面提到的“理论上是错误”的小于运算符，否则不能保证“很接近的点”在排序后连续排列
  // 另一个常见的处理方式是把坐标扩大很多倍（比如100000倍），然后四舍五入变成整点（计算完毕后再还原），用少许的精度损失换来鲁棒性和速度。
    sort(V, V+c);
    c = unique(V, V+c) - V;

    g.init(c);  //c是平面图的点数
    for(int i = 0; i < c; i++) {
        g.x[i] = V[i].x;
        g.y[i] = V[i].y;
    }
    for(int  i = 0; i < n; i++) {
        Vector v = p[(i+1)%n] - p[i];
        double len = Length(v);
        dis[i].pb(0);
        dis[i].pb(len);
        sort(dis[i].begin(), dis[i].end());
        int sz = dis[i].size();
        for(int j = 1; j < sz; j++) {
            Point a = p[i] + v*(dis[i][j-1]/len);
            Point b = p[i] + v*(dis[i][j]/len);
            if(a == b) continue;
            g.add(ID(a), ID(b));
        }
    }
    g.build();

    Poly po;
    for(int i = 0; i < g.faces.size(); i++) {
        if(g.area[i] < 0) {   // 对于连通图，惟一一个面积小于零的面是无限面
            po = g.faces[i];
            reverse(po.begin(),po.end());   // 对于内部区域来说，无限面多边形的各个顶点是顺时针的
            po = simplify(po);  // 无限面多边形上可能会有相邻共线点
            break;
        }
    }
    int m = po.size();
    printf("%d\n", m);
    int s = 0;
    for(int i = 0; i < m; i++) if(po[i] < po[s]) s = i;
    for(int i = s; i < m; i++) printf("%.4lf %.4lf\n", po[i].x, po[i].y);
    for(int i = 0; i < s; i++) printf("%.4lf %.4lf\n", po[i].x, po[i].y);
}


int main(){
    while(scanf("%d", &n)!=EOF) {
        int x,y;
        for(int i = 0; i < n; i++) {
            scanf("%d %d", &x, &y);
            p[i] = Point(x,y);
        }
        build_graph();
    }
    return 0;
}