平面区域专题

LA 2797 Monster Trap

如何判断一个平面区域是否有界？
想办法找出交点集合建图，考虑墙的厚度，
将每条边两边延长一点点，如果一个端点位于另一条线段内部，该点忽视

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
ll sqr(ll a){return a*a;}
ld sqr(ld a){return a*a;}
double sqr(double a){return a*a;}

ld PI = 3.141592653589793238462643383;
class P{
public:
    double x,y;
    P(double x=0,double y=0):x(x),y(y){}
    friend long double dis2(P A,P B){return sqr(A.x-B.x)+sqr(A.y-B.y);  }
    friend long double Dot(P A,P B) {return A.x*B.x+A.y*B.y; }
    friend long double Length(P A) {return sqrt(Dot(A,A)); }
    friend long double Angle(P A,P B) {return acos(Dot(A,B) / Length(A) / Length(B) ); }

    friend P operator- (P A,P B) { return P(A.x-B.x,A.y-B.y); }
    friend P operator+ (P A,P B) { return P(A.x+B.x,A.y+B.y); }
    friend P operator* (P A,double p) { return P(A.x*p,A.y*p); }
    friend P operator/ (P A,double p) { return P(A.x/p,A.y/p); }
    friend bool operator< (const P& a,const P& b) {return a.x<b.x||(a.x==b.x&& a.y<b.y);}

}; 
const double eps=1e-12;
int dcmp(double x) {
    if (fabs(x)<eps) return 0; else return x<0 ? -1 : 1; 
}
bool operator==(const P& a,const P& b) {
    return dcmp(a.x-b.x)==0 && dcmp(a.y-b.y) == 0;
} 
typedef P V;

double Cross(V A,V B) {return A.x*B.y - A.y*B.x;}
double Area2(P A,P B,P C) {return Cross(B-A,C-A);}
V Rotate(V A,double rad) {
    return V(A.x*cos(rad)-A.y*sin(rad),A.x*sin(rad)+A.y*cos(rad));
} 
// A 不是 0向量 
V Normal(V A) { 
    double L = Length(A);
    return V(-A.y/L , A.x/L); 
}

namespace complex_G{
    typedef complex<double> Point;
    //real(p):实部 imag(p):虚部 conj(p):共轭 
    typedef Point Vector;
    double Dot(Vector A,Vector B) {return real(conj(A)*B); }
    double Cross(Vector A,Vector B) {return imag(conj(A)*B); }
    Vector Rotate(Vector A,double rad) {return A*exp(Point(0,rad)); }
}
//Cross(v,w)==0(平行)时,不能调这个函数 
P GetLineIntersection(P p,V v,P Q,V w){
    V u = p-Q;
    double t = Cross(w,u)/Cross(v,w);
    return p+v*t;
}
P GetLineIntersectionB(P p,V v,P Q,V w){
    return GetLineIntersection(p,v-p,Q,w-Q);
}

double DistanceToLine(P p,P A,P B) {
    V v1 = B-A, v2 = p-A;
    return fabs(Cross(v1,v2))/Length(v1);
}
double DistanceToSegment(P p,P A,P B) {
    if (A==B) return Length(p-A);
    V v1 = B-A, v2 = p-A, v3 = p - B;
    if (dcmp(Dot(v1,v2))<0) return Length(v2);
    else if (dcmp(Dot(v1,v3))>0 ) return Length(v3);
    else return fabs(Cross(v1,v2) ) / Length(v1);
}
P GetLineProjection(P p,P A,P B) {
    V v=B-A;
    return A+v*(Dot(v,p-A)/Dot(v,v));
}
//规范相交-线段相交且交点不在端点 
bool SegmentProperIntersection(P a1,P a2,P b1,P 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(P p,P a1,P a2) {
    return dcmp(Cross(a1-p,a2-p)) == 0 && dcmp(Dot(a1-p,a2-p))<0;
}
P read_point() {
    P a;
    scanf("%lf%lf",&a.x,&a.y);
    return a;   
} 
#define MAXN (300)
int n, G[MAXN][MAXN], vis[MAXN], sz;
P p1[MAXN],p2[MAXN];
bool onAnySegment(P p) {
    Rep(i,n) if (OnSegment(p,p1[i],p2[i])) return 1;
    return 0;
}
bool IntsectAnySegment(P a,P b) {
    Rep(i,n) if (SegmentProperIntersection(a,b,p1[i],p2[i])) return 1;
    return 0;
}
bool find_path() {
    vector<P> v;
    v.pb(P());
    v.pb(P(1e5,1e5));
    Rep(i,n) {
        if (!onAnySegment(p1[i])) v.pb(p1[i]);
        if (!onAnySegment(p2[i])) v.pb(p2[i]);
    }
    sz=SI(v);
    MEM(G) MEM(vis)
    Rep(i,sz) Fork(j,i+1,sz-1) {
        G[i][j]=G[j][i]=!IntsectAnySegment(v[i],v[j]); 
    }
}
bool dfs(int u) {
    if (u==1) return 1;
    vis[u]=1;
    Rep(v,sz) {
    if (G[u][v] && !vis[v] && dfs(v))
        return 1;
    }
    return 0;
}

int main()
{
//  freopen("la2797.in","r",stdin);
//  freopen(".out","w",stdout);
    while(scanf("%d",&n)==1&&n) {
        Rep(i,n) {
            P a=read_point(),b=read_point();
            V v0=(a-b)/Length(a-b)*1e-6;
            p1[i]=a+v0;
            p2[i]=b-v0;
        }
        find_path();
        puts( (!dfs(0)) ?"yes":"no");
    }
    return 0;
}

LA 3218 Find the Border NEERC2004

PSLG板子题

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
ll sqr(ll a){return a*a;}
ld sqr(ld a){return a*a;}
double sqr(double a){return a*a;}

const double eps=1e-8;
int dcmp(double x) {
    if (fabs(x)<eps) return 0; else return x<0 ? -1 : 1; 
}
ld PI = 3.141592653589793238462643383;
class P{
public:
    double x,y;
    P(double x=0,double y=0):x(x),y(y){}
    friend long double dis2(P A,P B){return sqr(A.x-B.x)+sqr(A.y-B.y);  }
    friend long double Dot(P A,P B) {return A.x*B.x+A.y*B.y; }
    friend long double Length(P A) {return sqrt(Dot(A,A)); }
    friend long double Angle(P A,P B) {return acos(Dot(A,B) / Length(A) / Length(B) ); }
    friend P operator- (P A,P B) { return P(A.x-B.x,A.y-B.y); }
    friend P operator+ (P A,P B) { return P(A.x+B.x,A.y+B.y); }
    friend P operator* (P A,double p) { return P(A.x*p,A.y*p); }
    friend P operator/ (P A,double p) { return P(A.x/p,A.y/p); }
    friend bool operator< (const P& a,const P& b) {return dcmp(a.x-b.x)<0 ||(dcmp(a.x-b.x)==0&& dcmp(a.y-b.y)<0 );}

}; 
bool operator==(const P& a,const P& b) {
    return dcmp(a.x-b.x)==0 && dcmp(a.y-b.y) == 0;
} 
typedef P V;

double Cross(V A,V B) {return A.x*B.y - A.y*B.x;}
double Area2(P A,P B,P C) {return Cross(B-A,C-A);}

P GetLineIntersection(P p,V v,P Q,V w){
    V u = p-Q;
    double t = Cross(w,u)/Cross(v,w);
    return p+v*t;
}
P GetLineIntersectionB(P p,V v,P Q,V w){
    return GetLineIntersection(p,v-p,Q,w-Q);
}

bool SegmentProperIntersection(P a1,P a2,P b1,P 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(P p,P a1,P a2) {
    return dcmp(Cross(a1-p,a2-p)) == 0 && dcmp(Dot(a1-p,a2-p))<0;
}
P read_point() {
    P a;
    scanf("%lf%lf",&a.x,&a.y);
    return a;   
} 

typedef vector<P> Polygon;
double PolygonArea(Polygon &p) {
    double area=0;
    int n=p.size();
    For(i,n-2) area+=Cross(p[i]-p[0],p[i+1]-p[0]);
    return area/2;
} 


struct Edge{
    int from,to;
    double ang;
    Edge(int _from,int _to,double _ang):from(_from),
        to(_to),ang(_ang){}
};
#define MAXN (11111+10)
struct PSLG {
    int n,m,face_cnt;
    ld x[MAXN],y[MAXN];
    vector<Edge> edges;
    vi G[MAXN];
    int vis[MAXN*2],left[MAXN*2],prev[MAXN*2];
    vector<Polygon> faces;
    double area[MAXN];
    void init(int n) {
        this->n=n;
        Rep(i,n) G[i].clear();
        edges.clear();
        faces.clear();
    }
    double getAngle(int from,int to) {
        return atan2(y[to]-y[from],x[to]-x[from]);
    }
    void AddEdge(int from,int to) {
        edges.pb(Edge(from,to,getAngle(from,to)));
        edges.pb(Edge(to,from,getAngle(to,from)));
        m=SI(edges);
        G[from].pb(m-2);
        G[to].pb(m-1);
    }
    void Build() { 
        Rep(u,n) {
            int d=SI(G[u]);
            Rep(i,d) {
                Fork(j,i+1,d-1) {
                    if (edges[G[u][i]].ang>edges[G[u][j]].ang) {
                        swap(G[u][i],G[u][j]);
                    }
                }
            }
            Rep(i,d) {
                prev[G[u][(i+1)%d]]=G[u][i];
            }
        }
        MEM(vis)
        face_cnt=0;
        Rep(u,n) {
            Rep(i,SI(G[u])) {
                int e=G[u][i];
                if (!vis[e]) {
                    face_cnt++;
                    Polygon poly;
                    while(1) {
                        vis[e]=1;
                        left[e]=face_cnt;
                        int from = edges[e].from;
                        P p(x[from],y[from]);
                        poly.pb(p);
                        e=prev[e^1];
                        if (e==G[u][i]) break;
                    }
                    faces.pb(poly);
                }
            } 
        }
        Rep(i,face_cnt) {
            area[i]=PolygonArea(faces[i]);
        }
    }
}g;

int n, sz;
P p1[MAXN];
void find_path() {
    vector<P> v;
    vector<double> dis[MAXN];
    Rep(i,n) v.pb(p1[i]);
    Rep(i,n) {
        Fork(j,i+1,n-1)
            if (SegmentProperIntersection(p1[i],p1[(i+1)%n],p1[j],p1[(j+1)%n])) {
                P p=GetLineIntersectionB(p1[i],p1[(i+1)%n],p1[j],p1[(j+1)%n]);
                v.pb(p);
                dis[i].pb(Length(p-p1[i]));
                dis[j].pb(Length(p-p1[j]));
            }
    }
    sort(ALL(v));
    v.erase( unique(ALL(v)), v.end() );
    sz=SI(v);

    g.init(sz);
    Rep(i,sz) g.x[i]=v[i].x,g.y[i]=v[i].y;

    Rep(i,n) {
        V v1 = p1[(i+1)%n]-p1[i];
        double len=Length(v1);
        dis[i].pb(0); dis[i].pb(len);
        v1=v1/len;
        sort(ALL(dis[i]));  
        dis[i].erase(unique(ALL(dis[i])),dis[i].end());
        int tot=SI(dis[i]);
        Rep(j,tot-1) {
            P now=p1[i]+v1*dis[i][j];
            P now2=p1[i]+v1*dis[i][j+1];
            int id1=lower_bound(ALL(v),now)-v.begin();
            int id2=lower_bound(ALL(v),now2)-v.begin();
            if (id1==id2) continue;
            g.AddEdge(id1,id2);
        }
    }
    g.Build();
}
void simplify(Polygon& poly) {
    Polygon ans;
    int n=SI(poly);
    Rep(i,n) {
        if (dcmp(Cross(poly[i]-poly[(i+1)%n],poly[(i+1)%n]-poly[(i+2)%n]))!=0)
            ans.pb(poly[(i+1)%n]);
    }
    n=SI(ans);
    cout<<n<<endl;
    Rep(i,n) printf("%.4lf %.4lf\n",ans[i].x,ans[i].y);
}

int main()
{
//  freopen("la3218.in","r",stdin);
//  freopen("la3218.out","w",stdout);
    while(scanf("%d",&n)==1&&n) {
        Rep(i,n) {
            p1[i]=read_point(); 
        }
        find_path();
        Polygon poly;
        Rep(i,g.face_cnt) if (dcmp(g.area[i])<0) {
            poly=g.faces[i];
            reverse(ALL(poly));
            break;
        }
        simplify(poly);
    }
    return 0;
}

UVA 12296 Pieces and Discs

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
ll sqr(ll a){return a*a;}
ld sqr(ld a){return a*a;}
double sqr(double a){return a*a;}

const double eps=1e-8;
int dcmp(double x) {
    if (fabs(x)<eps) return 0; else return x<0 ? -1 : 1; 
}
ld PI = 3.141592653589793238462643383;
class P{
public:
    double x,y;
    P(double x=0,double y=0):x(x),y(y){}
    friend long double dis2(P A,P B){return sqr(A.x-B.x)+sqr(A.y-B.y);  }
    friend long double Dot(P A,P B) {return A.x*B.x+A.y*B.y; }
    friend long double Length(P A) {return sqrt(Dot(A,A)); }
    friend long double Angle(P A,P B) {return acos(Dot(A,B) / Length(A) / Length(B) ); }
    friend P operator- (P A,P B) { return P(A.x-B.x,A.y-B.y); }
    friend P operator+ (P A,P B) { return P(A.x+B.x,A.y+B.y); }
    friend P operator* (P A,double p) { return P(A.x*p,A.y*p); }
    friend P operator/ (P A,double p) { return P(A.x/p,A.y/p); }
    friend bool operator< (const P& a,const P& b) {return dcmp(a.x-b.x)<0 ||(dcmp(a.x-b.x)==0&& dcmp(a.y-b.y)<0 );}

}; 
bool operator==(const P& a,const P& b) {
    return dcmp(a.x-b.x)==0 && dcmp(a.y-b.y) == 0;
} 
typedef P V;

double Cross(V A,V B) {return A.x*B.y - A.y*B.x;}
double Area2(P A,P B,P C) {return Cross(B-A,C-A);}

P GetLineIntersection(P p,V v,P Q,V w){
    V u = p-Q;
    double t = Cross(w,u)/Cross(v,w);
    return p+v*t;
}
P GetLineIntersectionB(P p,V v,P Q,V w){
    return GetLineIntersection(p,v-p,Q,w-Q);
}

bool SegmentProperIntersection(P a1,P a2,P b1,P 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(P p,P a1,P a2) {
    return dcmp(Cross(a1-p,a2-p)) == 0 && dcmp(Dot(a1-p,a2-p))<=0;
}
P read_point() {
    P a;
    scanf("%lf%lf",&a.x,&a.y);
    return a;   
} 

typedef vector<P> Polygon;
double PolygonArea(Polygon &p) {
    double area=0;
    int n=p.size();
    For(i,n-2) area+=Cross(p[i]-p[0],p[i+1]-p[0]);
    return area/2;
} 


struct Edge{
    int from,to;
    double ang;
    Edge(int _from,int _to,double _ang):from(_from),
        to(_to),ang(_ang){}
};
#define MAXN (11111+10)
struct PSLG {
    int n,m,face_cnt;
    ld x[MAXN],y[MAXN];
    vector<Edge> edges;
    vi G[MAXN];
    int vis[MAXN*2],left[MAXN*2],prev[MAXN*2];
    vector<Polygon> faces;
    double area[MAXN];
    void init(int n) {
        this->n=n;
        Rep(i,n) G[i].clear();
        edges.clear();
        faces.clear();
    }
    double getAngle(int from,int to) {
        return atan2(y[to]-y[from],x[to]-x[from]);
    }
    void AddEdge(int from,int to) {
        edges.pb(Edge(from,to,getAngle(from,to)));
        edges.pb(Edge(to,from,getAngle(to,from)));
        m=SI(edges);
        G[from].pb(m-2);
        G[to].pb(m-1);
    }
    void Build() { 
        Rep(u,n) {
            int d=SI(G[u]);
            Rep(i,d) {
                Fork(j,i+1,d-1) {
                    if (edges[G[u][i]].ang>edges[G[u][j]].ang) {
                        swap(G[u][i],G[u][j]);
                    }
                }
            }
            Rep(i,d) {
                prev[G[u][(i+1)%d]]=G[u][i];
            }
        }
        MEM(vis)
        face_cnt=0;
        Rep(u,n) {
            Rep(i,SI(G[u])) {
                int e=G[u][i];
                if (!vis[e]) {
                    face_cnt++;
                    Polygon poly;
                    while(1) {
                        vis[e]=1;
                        left[e]=face_cnt;
                        int from = edges[e].from;
                        P p(x[from],y[from]);
                        poly.pb(p);
                        e=prev[e^1];
                        if (e==G[u][i]) break;
                    }
                    faces.pb(poly);
                }
            } 
        }
        Rep(i,face_cnt) {
            area[i]=PolygonArea(faces[i]);
        }
    }
}g;

int n, sz, m;
int L,W;
P p1[MAXN],p2[MAXN];
void find_path() {
    vector<P> v;
    Rep(i,n) v.pb(p1[i]),v.pb(p2[i]);
    Rep(i,n) {
        Fork(j,i+1,n-1)
            if (SegmentProperIntersection(p1[i],p2[i],p1[j],p2[j])) {
                P p=GetLineIntersectionB(p1[i],p2[i],p1[j],p2[j]);
                v.pb(p);
            }
    }
    sort(ALL(v));
    v.erase( unique(ALL(v)), v.end() );
    sz=SI(v);
    g.init(sz);
    Rep(i,sz) g.x[i]=v[i].x,g.y[i]=v[i].y;
    Rep(i,sz) {
        Fork(j,i+1,sz-1) {
            bool fl=1;
            Rep(k,sz)
                if (k!=i&&k!=j&&OnSegment(v[k],v[i],v[j]))
                    {fl=0;break;}
            if (!fl) continue;

            Rep(k,n) {
                if (OnSegment(v[i],p1[k],p2[k]) && OnSegment(v[j],p1[k],p2[k]) ) {
                    fl=0; break;
                }
            }
            if (!fl) {
                g.AddEdge(i,j);
            }
        }
    }
    g.Build();
}

int isPointInPolygon(P p,Polygon poly) {
    int wn=0;
    int n=poly.size();
    Rep(i,n) {
        if (OnSegment(p,poly[i],poly[(i+1)%n])) return -1;
        int k=dcmp(Cross(poly[(i+1)%n]-poly[i],p-poly[i]));
        int d1 = dcmp(poly[i].y-p.y);
        int d2 = dcmp(poly[(i+1)%n].y-p.y);
        if ( k > 0 && d1 <= 0 && d2 > 0 ) wn++;
        if ( k < 0 && d2 <= 0 && d1 > 0 ) wn--;
    }
    if (wn!=0) return 1;
    return 0;
}

P GetLineProjection(P p,P A,P B) {
    V v=B-A;
    return A+v*(Dot(v,p-A)/Dot(v,v));
}
bool is_intesect(Polygon poly,P o,double r) {
    int n=SI(poly);
    if (isPointInPolygon(o,poly)==1) return 1;
    Rep(i,n) {
        if (dcmp(Length(poly[i]-o)-r)<0) return 1;
    }
    Rep(i,n) {
        P A=poly[i],B=poly[(i+1)%n];
        if (dcmp(Length((A+B)/2-o)-r)<0) return 1;
    }
    Rep(i,n) {
        P A=poly[i],B=poly[(i+1)%n];
        P C=GetLineProjection(o,A,B);
        if (C==A||C==B) continue;
        if (dcmp(Length(C-o)-r)<0 && OnSegment(C,A,B)) return 1;
    }
    return 0;

}

int main()
{
//  freopen("uva12296.in","r",stdin);
//  freopen(".out","w",stdout);
    while(scanf("%d%d%d%d",&n,&m,&L,&W)&&n) {
        Rep(i,n) {
            p1[i]=read_point(); p2[i]=read_point();
        }
        P A=P(),B=P(0,W),C=P(L,W),D=P(L,0);
        p1[n]=A,p2[n]=B;++n;p1[n]=B;p2[n]=C;++n;
        p1[n]=C,p2[n]=D;++n;p1[n]=D;p2[n]=A;++n;
        find_path();
        Rep(i,m) {
            vector<double > ans;
            P o=read_point(); double r=read();
            Rep(i,g.face_cnt) if (dcmp(g.area[i])>=0) {
                if (is_intesect(g.faces[i],o,r)) {
                    ans.pb(g.area[i]);
                }
            }
            sort(ALL(ans));
            cout<<SI(ans);
            Rep(i,SI(ans)) printf(" %.2lf",ans[i]);puts("");
        }puts("");
    }
    return 0;
}

LA 3176 Art of War CERC2004

让我们先把图画出来冷静一下
我没有判多边形包含的情况，不过LA数据好像很弱

from graphics import *  

win = GraphWin('CSSA', 700, 700)   

pt = Point(3, 2)
pt.draw(win) 
pt = Point(11, 8)
pt.draw(win) 
pt = Point(12, 17)
pt.draw(win) 
pt = Point(1, 19)
pt.draw(win) 
pt = Point(3, 2)
pt.draw(win) 
pt = Point(11, 8)
pt.draw(win) 
pt = Point(12, 17)
pt.draw(win) 
pt = Point(1, 19)
pt.draw(win) 
line = Line(Point(0, 0), Point(10, 0))
line.draw(win)  
line = Line(Point(10, 0), Point(20, 0))
line.draw(win)  
line = Line(Point(20, 0), Point(20, 10))
line.draw(win)  
line = Line(Point(20, 10), Point(20, 20))
line.draw(win)  
line = Line(Point(20, 20), Point(10, 20))
line.draw(win)  
line = Line(Point(10, 20), Point(0, 20))
line.draw(win)  
line = Line(Point(0, 20), Point(0, 10))
line.draw(win)  
line = Line(Point(0, 10), Point(0, 0))
line.draw(win)  
line = Line(Point(10, 0), Point(10, 10))
line.draw(win)  
line = Line(Point(0, 10), Point(10, 10))
line.draw(win)  
line = Line(Point(20, 10), Point(10, 10))
line.draw(win)  
line = Line(Point(10, 20), Point(10, 10))
line.draw(win)
win.getMouse()  
win.close()  

#include<bits/stdc++.h>
using namespace std;
#define For(i,n) for(int i=1;i<=n;i++)
#define Fork(i,k,n) for(int i=k;i<=n;i++)
#define Rep(i,n) for(int i=0;i<n;i++)
#define ForD(i,n) for(int i=n;i;i--)
#define ForkD(i,k,n) for(int i=n;i>=k;i--)
#define RepD(i,n) for(int i=n;i>=0;i--)
#define Forp(x) for(int p=Pre[x];p;p=Next[p])
#define Forpiter(x) for(int &p=iter[x];p;p=Next[p])  
#define Lson (o<<1)
#define Rson ((o<<1)+1)
#define MEM(a) memset(a,0,sizeof(a));
#define MEMI(a) memset(a,127,sizeof(a));
#define MEMi(a) memset(a,128,sizeof(a));
#define INF (2139062143)
#define F (100000007)
#define pb push_back
#define mp make_pair 
#define fi first
#define se second
#define vi vector<int> 
#define pi pair<int,int>
#define SI(a) ((a).size())
#define ALL(a) (a).begin(), (a).end()
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
ll mul(ll a,ll b){return (a*b)%F;}
ll add(ll a,ll b){return (a+b)%F;}
ll sub(ll a,ll b){return (a-b+llabs(a-b)/F*F+F)%F;}
void upd(ll &a,ll b){a=(a%F+b%F)%F;}
int read()
{
    int x=0,f=1; char ch=getchar();
    while(!isdigit(ch)) {if (ch=='-') f=-1; ch=getchar();}
    while(isdigit(ch)) { x=x*10+ch-'0'; ch=getchar();}
    return x*f;
} 
ll sqr(ll a){return a*a;}
ld sqr(ld a){return a*a;}
double sqr(double a){return a*a;}

const double eps=1e-8;
int dcmp(double x) {
    if (fabs(x)<eps) return 0; else return x<0 ? -1 : 1; 
}
ld PI = 3.141592653589793238462643383;
class P{
public:
    double x,y;
    P(double x=0,double y=0):x(x),y(y){}
    friend long double dis2(P A,P B){return sqr(A.x-B.x)+sqr(A.y-B.y);  }
    friend long double Dot(P A,P B) {return A.x*B.x+A.y*B.y; }
    friend long double Length(P A) {return sqrt(Dot(A,A)); }
    friend long double Angle(P A,P B) {return acos(Dot(A,B) / Length(A) / Length(B) ); }
    friend P operator- (P A,P B) { return P(A.x-B.x,A.y-B.y); }
    friend P operator+ (P A,P B) { return P(A.x+B.x,A.y+B.y); }
    friend P operator* (P A,double p) { return P(A.x*p,A.y*p); }
    friend P operator/ (P A,double p) { return P(A.x/p,A.y/p); }
    friend bool operator< (const P& a,const P& b) {return dcmp(a.x-b.x)<0 ||(dcmp(a.x-b.x)==0&& dcmp(a.y-b.y)<0 );}

}; 
bool operator==(const P& a,const P& b) {
    return dcmp(a.x-b.x)==0 && dcmp(a.y-b.y) == 0;
} 
typedef P V;

double Cross(V A,V B) {return A.x*B.y - A.y*B.x;}
double Area2(P A,P B,P C) {return Cross(B-A,C-A);}

P GetLineIntersection(P p,V v,P Q,V w){
    V u = p-Q;
    double t = Cross(w,u)/Cross(v,w);
    return p+v*t;
}
P GetLineIntersectionB(P p,V v,P Q,V w){
    return GetLineIntersection(p,v-p,Q,w-Q);
}

bool SegmentProperIntersection(P a1,P a2,P b1,P 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(P p,P a1,P a2) {
    return dcmp(Cross(a1-p,a2-p)) == 0 && dcmp(Dot(a1-p,a2-p))<=0;
}
P read_point() {
    P a;
    scanf("%lf%lf",&a.x,&a.y);
    return a;   
} 

typedef vector<P> Polygon;
double PolygonArea(Polygon &p) {
    double area=0;
    int n=p.size();
    For(i,n-2) area+=Cross(p[i]-p[0],p[i+1]-p[0]);
    return area/2;
} 


struct Edge{
    int from,to;
    double ang;
    Edge(int _from,int _to,double _ang):from(_from),
        to(_to),ang(_ang){}
};
#define MAXN (11111+10)
struct PSLG {
    int n,m,face_cnt;
    ld x[MAXN],y[MAXN];
    vector<Edge> edges;
    vi G[MAXN];
    int vis[MAXN*2],left[MAXN*2],prev[MAXN*2];
    vector<Polygon> faces;
    vi faceE[MAXN];
    double area[MAXN];
    void init(int n) {
        this->n=n;
        Rep(i,n) G[i].clear();
        edges.clear();
        faces.clear();
    }
    double getAngle(int from,int to) {
        return atan2(y[to]-y[from],x[to]-x[from]);
    }
    void AddEdge(int from,int to) {
        edges.pb(Edge(from,to,getAngle(from,to)));
        edges.pb(Edge(to,from,getAngle(to,from)));
        m=SI(edges);
        G[from].pb(m-2);
        G[to].pb(m-1);
    }
    void Build() { 
        Rep(u,n) {
            int d=SI(G[u]);
            Rep(i,d) {
                Fork(j,i+1,d-1) {
                    if (edges[G[u][i]].ang>edges[G[u][j]].ang) {
                        swap(G[u][i],G[u][j]);
                    }
                }
            }
            Rep(i,d) {
                prev[G[u][(i+1)%d]]=G[u][i];
            }
        }
        MEM(vis)
        face_cnt=0;
        Rep(u,n) {
            Rep(i,SI(G[u])) {
                int e=G[u][i];
                if (!vis[e]) {
                    faceE[face_cnt].clear();
                    face_cnt++;
                    Polygon poly;
                    while(1) {
                        vis[e]=1;
                        left[e]=face_cnt;
                        int from = edges[e].from;
                        P p(x[from],y[from]);
                        poly.pb(p); faceE[face_cnt-1].pb(e);
                        e=prev[e^1];
                        if (e==G[u][i]) break;
                    }
                    faces.pb(poly);
                }
            } 
        }
        Rep(i,face_cnt) {
            area[i]=PolygonArea(faces[i]);
        }
    }
}g;

int n, sz, m;
int L,W;
P p1[MAXN],p2[MAXN];
void find_path() {
    vector<P> v;
    Rep(i,m) v.pb(p1[i]),v.pb(p2[i]);
    sort(ALL(v));
    v.erase( unique(ALL(v)), v.end() );
    sz=SI(v);
    g.init(sz);
    Rep(i,sz) g.x[i]=v[i].x,g.y[i]=v[i].y;
    Rep(i,m) {
        int id1=lower_bound(ALL(v),p1[i])-v.begin();
        int id2=lower_bound(ALL(v),p2[i])-v.begin();
        g.AddEdge(id1,id2);
    }
    g.Build();
}

int isPointInPolygon(P p,Polygon poly) {
    int wn=0;
    int n=poly.size();
    Rep(i,n) {
        if (OnSegment(p,poly[i],poly[(i+1)%n])) return -1;
        int k=dcmp(Cross(poly[(i+1)%n]-poly[i],p-poly[i]));
        int d1 = dcmp(poly[i].y-p.y);
        int d2 = dcmp(poly[(i+1)%n].y-p.y);
        if ( k > 0 && d1 <= 0 && d2 > 0 ) wn++;
        if ( k < 0 && d2 <= 0 && d1 > 0 ) wn--;
    }
    if (wn!=0) return 1;
    return 0;
}

P GetLineProjection(P p,P A,P B) {
    V v=B-A;
    return A+v*(Dot(v,p-A)/Dot(v,v));
}
P ask[MAXN];
int id[MAXN],hid[MAXN];

vi call(int p) {
    vi ans;
    vi v =  g.faceE[p];
    Rep(j,SI(v)) {
        int t=g.left[v[j]^1]-1;
        if (dcmp(g.area[t])>=0) ans.pb(hid[t]);
    }
    sort(ALL(ans));
    int sz=unique(ALL(ans))-ans.begin();
    cout<<sz;
    Rep(i,sz) printf(" %d",ans[i]+1);puts("");
    return ans;
}
int main()
{
//  freopen("la3176.in","r",stdin);
//  freopen(".out","w",stdout);
    while(scanf("%d%d",&n,&m)&&n) {
        Rep(i,n) ask[i]=read_point();
        Rep(i,m) {
            p1[i]=read_point(); p2[i]=read_point();
        }
        find_path();
        Rep(j,n) {
            Rep(i,g.face_cnt) if (dcmp(g.area[i])>=0 &&isPointInPolygon(ask[j],g.faces[i]) ) {
                id[j]=i; hid[i]=j;
            }
        }
        Rep(j,n) {
            Rep(i,g.face_cnt) if (dcmp(g.area[i])>=0 &&isPointInPolygon(ask[j],g.faces[i])&&g.area[i]<g.area[j] ) {

                id[j]=i; hid[i]=j;
            }
        }

        Rep(j,n) call(id[j]);
    }
    return 0;
}