UVA LA 2797 PSLG 线段闭合圈 神奇的精度问题

分析：

本题的输入是一个PSLG，目标是判断起点和终点是否在同一个区域内，因此一个可行的方法是先找出所有区域，然后判断起点和终点分别属于哪个区域。但笔者并不推荐这样做，因为这种做法不仅麻烦，而且很容易出错。这道题看上去像个迷宫，可不可以用图论求解呢比如，每条线段的端点看成一个点，在加上起点和无穷远点（随便取一个坐标很大的点）构图。如果俩个点u和v的线段没有与其他线段规范相交；则连接一条边（表示可以从点u沿着直线直接走到点v），最后做一次BFS，看看起点和无穷远点是否连通即可。

注意，线段交点并没有参与构图（想一想，为什么）。

看上去似乎很合理，但其实这样做不仅使错的，而且错的很离谱。

如图所示，S和A，A和T都有边直接相连，因此S和T连通。问题出在哪里？实际上，“S可以直接到达A”和“A可以直接到达T”中的A并不是同一个点。我们把迷宫墙的厚度画出来，就容易理解了，如图所示。（此处没图，因为不会画，但是为了补充我自己的思路，说一下，有兴趣看图的参考大白书283页）。

S可以直接到达是墙内点A,可以直接到达T的是墙外点A‘，而墙内点A和墙外点A’却被墙挡住了，过不去。

解决方法有很多，其中一个容易理解，程序也很好写的方法，那就是吧每条线段延长一点点，则原先仅有公共端点的俩条线段变成了相交线段，如图所示。

这样一来，就无法从S出去了。需要注意的是，还有一个小小的细节不能忽略；如果要输入的俩条有公共端点的线段共线，则上述算法会出问题（想一想，为什么）。解决方案是在线段加宽后判断一下，如果加宽后的某个端点位于另一条线段的内部，则该端点不参与构图。

题目思路：白书上的例题。  如果存在一条路径，那么一定可以经过给定线段的顶点，这样就可以建图了。

1  线段延长--防止公共端点判定为中继

2  判断点是不是在其他线段上，防止公共端点且共线的情形。

如果有情形2  就不放进考虑的点

注意 OnSegment如果包含端点的模板，则要特判不是端点

额，eps10-10 wa了  10-12 ac了... （此处不知道具体为什么，精度问题总是很奇怪）。

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<cctype>
#include<string>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
using namespace std;
const double eps=1e-15;
const int maxn=50000+10;
int dcmp(double x)
{
    if(fabs(x)<eps) return 0;
    return x>0?1:-1;
    //return fabs(x) < eps ? 0 : (x > 0 ? 1 : -1);
}

struct point
{
  double x;
  double y;
  point(){}
  point(double x,double  y):x(x),y(y){}
  void in()
  {
      cin>>x>>y;
  }
  void out()
  {
      cout<<x<<' '<<y<<endl;
  }
  point operator + (const point &t) const
  {
      return point(x+t.x,y+t.y);
  }
  point operator - (const point &t) const
  {
      return point(x-t.x,y-t.y);
  }
  point operator * (const double &t) const
  {
      return point(x*t,y*t);
  }
  point operator / (const double &t) const
  {
      return point(x/t,y/t);
  }
};
double cross(point a,point b)
{
    return a.x*b.y-a.y*b.x;
}
double dot(point a,point b)
{
    return a.x*b.x+a.y*b.y;
}
double length(point a)
{
    return sqrt(dot(a,a));
}
point nomal(point t)
{
    double l=length(t);
    return  point(-t.y/l,t.x/l);
}
struct line
{
    point p;
    point v;
    double ang;
    line() {}
    line(point p,point v):p(p),v(v){
        ang=atan2(v.y,v.x);
    }
    bool operator < (const line &l) const
    {
        return ang<l.ang;
    }
};

bool onleft(line l,point p)
{
    return cross(l.v,p-l.p)>0;
}
point getintersection(line a,line b)
{
    point u=a.p-b.p;
    double t=cross(b.v,u)/cross(a.v,b.v);
    return a.p+a.v*t;
}
bool sgementproperintersection(point a1,point a2,point b1,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(point p,point a1,point a2)
{
    return dcmp(cross(a1-p,a2-p))==0&&dcmp(dot(a1-p,a2-p))<0;
}
int n;
point p1[105],p2[105];
bool onanysegment(point p)
{
    for(int i=0;i<n;i++)
    {
        if(onsegment(p,p1[i],p2[i]))
            return 1;
    }
    return 0;
}
bool interanyseg(point a,point b)
{
    for(int i=0;i<n;i++)
    {
        if(sgementproperintersection(a,b,p1[i],p2[i]))
            return 1;
    }
    return 0;
}
int dis[210][210];
bool vis[210];
void init()
{
    memset(dis,0,sizeof(dis));
    memset(vis,0,sizeof(vis));
}
bool dfs(int x)
{
    if(x==1) return 1;
    vis[x]=1;
    for(int i=0;i<205;i++)
    {
        if(dis[x][i]&&!vis[i]&&dfs(i)) return 1;
    }
    return 0;
}
bool judge()
{
    vector<point> v;
    v.push_back(point(0,0));
    v.push_back(point(1e5,1e5));

    for(int i=0;i<n;i++)
    {
        if(!onanysegment(p1[i])) v.push_back(p1[i]);
        if(!onanysegment(p2[i])) v.push_back(p2[i]);
    }
    int sz=v.size();
    for(int i=0;i<sz;i++)
        for(int j=i+1;j<sz;j++)
    {
        if(!interanyseg(v[i],v[j]))
        {
            dis[i][j]=1;
            dis[j][i]=1;
        }
    }
    return dfs(0);
}
int main()
{
    point a,b;
    double off=1e-6;
    while(cin>>n&&n)
    {
        init();
        for(int i=0;i<n;i++)
        {
            a.in();
            b.in();
            point v=b-a;
            v=v/length(v);
            p1[i]=a-v*off;
            p2[i]=b+v*off;
        }
        if(judge()) cout<<"no"<<endl;
        else
            cout<<"yes"<<endl;
    }
    return 0;
}