题意

PDF

分析

虽然只找外轮廓，但是时间复杂度不比PSLG优秀，所以可以当做联系PSLG的题做。

PSLG框架

1. 找出所有交点
2. 交点按序连边
3. 把边按极角序排序
4. 逆时针找圈

然后何以会顺时针找出无限区域的边呢？缘于这一段：

for(int i=0;i<d;++i)
    prev[G[u][(i+1)%d]]=G[u][i];

边prev连向极角序次小的。极角序最小的边的prev连向极角序最大的。

然后在边界上就会顺时针找下去。但是在内部的时候这些边无疑会被逆时针遍历到，所以没有影响。

于是找出无限区域的轮廓的特殊性在于它的有向面积是负的。

时间复杂度主要是找轮廓时遍历边的\(O(n^2)\)

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<ctime>
#include<cstring>
#define rg register
#define il inline
#define co const
template<class T>il T read()
{
    rg T data=0;
    rg int w=1;
    rg char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        data=data*10+ch-'0';
        ch=getchar();
    }
    return data*w;
}
template<class T>T read(T&x)
{
    return x=read<T>();
}
using namespace std;
typedef long long ll;

co double eps=1e-8;

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

struct Point
{
    double x,y;
    
    Point(double x=0,double y=0)
    :x(x),y(y){}
    
    bool operator<(co Point&p)co
    {
        return dcmp(x-p.x)<0||(dcmp(x-p.x)==0&&dcmp(y-p.y)<0);
    }
    
    bool operator==(co Point&p)co
    {
        return dcmp(x-p.x==0)&&dcmp(y-p.y)==0;
    }
};
typedef Point Vector;

Vector operator+(co Vector&A,co Vector&B)
{
    return Vector(A.x+B.x,A.y+B.y);
}

Vector operator-(co Vector&A,co Vector&B)
{
    return Vector(A.x-B.x,A.y-B.y);
}

Vector operator*(co Vector&A,double p)
{
    return Vector(A.x*p,A.y*p);
}

double Dot(co Vector&A,co Vector&B)
{
    return A.x*B.x+A.y*B.y;
}

double Cross(co Vector&A,co Vector&B)
{
    return A.x*B.y-A.y*B.x;
}

double Length(co Vector&A)
{
    return sqrt(Dot(A,A));
}

typedef vector<Point> Polygon;

Point LineLineIntersection(co Point&P,co Vector&v,co Point&Q,co Vector&w)
{
    Vector u=P-Q;
    double t=Cross(w,u)/Cross(v,w);
    return P+v*t;
}

bool SegmentProperIntersection(co Point&a1,co Point&a2,co Point&b1,co Point&b2)
{
    double c1=Cross(a2-a1,b1-a1),c2=Cross(a2-a1,b2-a1),
           c3=Cross(b2-b1,a1-b1),c4=Cross(b2-b1,a2-b1);
    return dcmp(c1)*dcmp(c2)<0&&dcmp(c3)*dcmp(c4)<0;
}

bool OnSegment(co Point&p,co Point&a1,co Point&a2)
{
    return dcmp(Cross(a1-p,a2-p))==0&&dcmp(Dot(a1-p,a2-p))<0;
}

double PolygonArea(co Polygon&poly)
{
    double area=0;
    int n=poly.size();
    for(int i=1;i<n-1;++i)
        area+=Cross(poly[i]-poly[0],poly[(i+1)%n]-poly[0]);
    return area/2;
}

struct Edge
{
    int from,to;
    double ang;
};

co int MAXN=1e4;

struct PSLG
{
    int n,m,face_cnt;
    double x[MAXN],y[MAXN];
    vector<Edge>edges;
    vector<int>G[MAXN];
    int vis[MAXN*2];
    int left[MAXN*2];
    int prev[MAXN*2];
    
    vector<Polygon>faces;
    double area[MAXN];
    
    void Init(int n)
    {
        this->n=n;
        for(int i=0;i<n;++i)
            G[i].clear();
        edges.clear();
        faces.clear();
    }
    
    double Angle(int from,int to)
    {
        return atan2(y[to]-y[from],x[to]-x[from]);
    }
    
    void AddEdge(int from,int to)
    {
        edges.push_back((Edge){from,to,Angle(from,to)});
        edges.push_back((Edge){to,from,Angle(to,from)});
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    
    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)
                prev[G[u][(i+1)%d]]=G[u][i];
        }
        
        fill(vis,vis+m,0);
        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++;
                    Polygon poly;
                    for(;;)
                    {
                        vis[e]=1;
                        left[e]=face_cnt;
                        int from=edges[e].from;
                        poly.push_back(Point(x[from],y[from]));
                        e=prev[e^1];
                        if(e==G[u][i])
                            break;
                        assert(vis[e]==0);
                    }
                    faces.push_back(poly);
                }
            }
        
        for(int i=0;i<faces.size();++i)
        {
            area[i]=PolygonArea(faces[i]);
        }
    }
}g;

co int MAXP=100;
int n,c;
Point P[MAXP];

Point V[MAXP*(MAXP-1)/2+MAXP];

int ID(Point P)
{
    return lower_bound(V,V+c,P)-V;
}

Polygon Simplify(co Polygon&poly)
{
    Polygon ans;
    int n=poly.size();
    for(int i=0;i<n;++i)
    {
        co Point&a=poly[i];
        co Point&b=poly[(i+1)%n];
        co Point&c=poly[(i+2)%n];
        if(dcmp(Cross(a-b,c-b))!=0)
            ans.push_back(b);
    }
    return ans;
}

void BuildGraph()
{
    c=n;
    for(int i=0;i<n;++i)
        V[i]=P[i];
        
    vector<double>dist[MAXP];
    for(int i=0;i<n;++i)
        for(int j=i+1;j<n;++j)
            if(SegmentProperIntersection(P[i],P[(i+1)%n],P[j],P[(j+1)%n]))
            {
                Point p=LineLineIntersection(P[i],P[(i+1)%n]-P[i],P[j],P[(j+1)%n]-P[j]);
                V[c++]=p;
                dist[i].push_back(Length(p-P[i]));
                dist[j].push_back(Length(p-P[j]));
            }
            
    sort(V,V+c);
    c=unique(V,V+c)-V;
    
    g.Init(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);
        dist[i].push_back(0);
        dist[i].push_back(len);
        sort(dist[i].begin(),dist[i].end());
        int sz=dist[i].size();
        for(int j=1;j<sz;++j)
        {
            Point a=P[i]+v*(dist[i][j-1]/len);
            Point b=P[i]+v*(dist[i][j]/len);
            if(a==b)
                continue;
            g.AddEdge(ID(a),ID(b));
        }
    }
    
    g.Build();
    
    Polygon poly;
    for(int i=0;i<g.faces.size();++i)
        if(g.area[i]<0)
        {
            poly=g.faces[i];
            reverse(poly.begin(),poly.end());
            poly=Simplify(poly);
            break;
        }
    
    int m=poly.size();
    printf("%d\n",m);
    
    int start=0;
    for(int i=0;i<m;++i)
        if(poly[i]<poly[start])
            start=i;
    for(int i=start;i<m;++i)
        printf("%.4lf %.4lf\n",poly[i].x,poly[i].y);
    for(int i=0;i<start;++i)
        printf("%.4lf %.4lf\n",poly[i].x,poly[i].y);
}

int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<n;++i)
        {
            int x,y;
            read(x),read(y);
            P[i]=Point(x,y);
        }
        BuildGraph();
    }
    return 0;
}