USACO6.5-Closed Fences：计算几何

Closed Fences

A closed fence in the plane is a set of non-crossing, connected line
segments with N corners (3 < N < 200). The corners or vertices
are each distinct and are listed in counter-clockwise order in an array
{x_i, y_i}, i in (1..N).

Every pair of adjacent vertices defines a side of the fence. Thus
{x_i y_i x_i+1 y_i+1} is a side
of the fence for all i in (1..N). For our purposes, N+1 = 1, so that
the first and last vertices making the fence closed.

Here is a typical closed fence and a point x,y:

                         * x3,y3
                 x5,y5  / \
    x,y *          *   /   \
                  / \ /     \
                 /   *       \
           x6,y6*   x4,y4     \
                |              \
                |               \
           x1,y1*----------------* x2,y2

Write a program which will do the following:

Test an ordered list of vertices {x_i,y_i}, i in (1..N) to see if the array is a valid fence.
Find the set of fence sides that a person (with no height) who is standing in the plane at position (x,y) can "see" when looking at the fence. The location x,y may fall anywhere not on the fence.

A fence side can be seen if there exists a ray that connects (x,y) and any point on the side, and the ray does not intersect any other side of the fence. A side that is parallel to the line of sight is not considered visible. In the figure, above the segments x3,y3-x4,y4; x5,y5-x6,y6; and x6-y6-x1,y1 are visible or partially visible from x,y.

PROGRAM NAME: fence4

INPUT FORMAT

Line 1:	N, the number of corners in the fence
Line 2:	Two space-separated integers, x and y, that are the location of the observer. Both integers will fit into 16 bits.
Line 3-N+2:	A pair of space-separated integers denoting the X,Y location of the corner. The pairs are given in counterclockwise order. Both integers are no larger than 1000 in magnitude.

NOTE: I have added anNew test case #12 for this task. Let me know if you think it's wrong. Rob Be sure to include USACO in your mail subject!

SAMPLE INPUT (file fence4.in)

OUTPUT FORMAT

If the sequence is not a valid fence, the output is a single line containing the word "NOFENCE".

Otherwise, the output is a listing of visible fence segments, one per line, shown as four space-separated integers that represent the two corners. Express the points in the segment by showing first the point that is earlier in the input, then the point that is later. Sort the segments for output by examining the last point and showing first those points that are earlier in the input. Use the same rule on the first of the two points in case of ties.

SAMPLE OUTPUT (file fence4.out)

一道计算几何，需要细心做，特判几种情况，一种是点在某段篱笆的平行线上，这种情况是不能算看到的，这也是我第一次WA的原因。。。。T.T
一种是将端点沿着篱笆移动一段很小的距离，这样就避免了篱笆在端点处相交的情况。
还有就是按题目要求来排序。
这题要是没数据的话，我肯定找不到我错在哪的 o(>﹏<)o

Executing...
   Test 1: TEST OK [0.003 secs, 3508 KB]
   Test 2: TEST OK [0.003 secs, 3508 KB]
   Test 3: TEST OK [0.003 secs, 3508 KB]
   Test 4: TEST OK [0.005 secs, 3508 KB]
   Test 5: TEST OK [0.003 secs, 3508 KB]
   Test 6: TEST OK [0.014 secs, 3508 KB]
   Test 7: TEST OK [0.008 secs, 3508 KB]
   Test 8: TEST OK [0.008 secs, 3508 KB]
   Test 9: TEST OK [0.011 secs, 3508 KB]
   Test 10: TEST OK [0.008 secs, 3508 KB]
   Test 11: TEST OK [0.003 secs, 3508 KB]
   Test 12: TEST OK [0.003 secs, 3508 KB]
 
All tests OK.

 /*
 TASK:fence4
 LANG:C++
 */
 
 #include <iostream>
 #include <vector>
 #include <stdlib.h>
 #include <stdio.h>
 #include <cmath>
 using namespace std;
 
 //定义点
 struct Point
 {
     double x;
     double y;
 };
 typedef Point Vector;
 bool operator == (const Point& p1, const Point& p2)
 {
     return fabs(p1.x - p2.x)<1e- && fabs(p1.y - p2.y)<1e-;
 }
 typedef struct Point point;
 Vector operator - (const Point& A, const Point& B)
 {
     return Vector{A.x-B.x, A.y-B.y};
 }
 double Cross(const Vector& A, const Vector& B)
 {
     return A.x*B.y - A.y*B.x;
 }
 //叉积
 double multi(point p0, point p1, point p2)
 {
     return (p1.x - p0.x )*( p2.y - p0.y )-( p2.x -p0.x )*( p1.y -p0.y );
 }
 //点积
 double Dot(Vector A,Vector B)
 {
     return A.x*B.x+A.y*B.y;
 }
 
 //相交返回true,否则为false, 接口为两线段的端点
 bool isIntersected(point s1,point e1, point s2,point e2)
 {
     if(s1==s2 || s1==e2 || e1==s2 || e1==e2)
     {
         return false;
     }
     return (max(s1.x,e1.x) >=min(s2.x,e2.x)) &&
            (max(s2.x,e2.x)>=min(s1.x,e1.x)) &&
            (max(s1.y,e1.y) >=min(s2.y,e2.y)) &&
            (max(s2.y,e2.y) >=min(s1.y,e1.y)) &&
            (multi(s1,s2,e1)*multi(s1,e1,e2)>) &&
            (multi(s2,s1,e2)*multi(s2,e2,e1)>);
 }
 
 point ps[];
 double x,y;
 int n ;
 bool check(int idx)
 {
     point pos=point {x,y};
     // 特判pos与线段idx平行的情况
     if(fabs(Cross(ps[idx]-pos,ps[idx+]-pos))<1e-)
     {
         return false;
     }
 
     bool flag=false;
     for(int i=; i<n; i++)
     {
         // 将ps[idx]移动一小段距离
         if(i==idx)
             continue;
         double dx=(ps[idx+].x-ps[idx].x)*1e-;
         double dy=(ps[idx+].y-ps[idx].y)*1e-;
 
         if(isIntersected(pos,point {ps[idx].x+dx,ps[idx].y+dy},ps[i],ps[i+]))
             flag=true;
     }
     if(!flag)
         return true;
     for(int i=; i<n; i++)
     {
         if(i==idx)
             continue;
 
         double dx=(ps[idx].x-ps[idx+].x)*1e-;
         double dy=(ps[idx].y-ps[idx+].y)*1e-;
 
         if(isIntersected(pos,point {ps[idx+].x+dx,ps[idx+].y+dy},ps[i],ps[i+]))
             return false;
     }
     return true;
 }
 
 int main()
 {
     freopen("fence4.in","r",stdin);
     freopen("fence4.out","w",stdout);
 
     cin>>n;
 
     scanf("%lf%lf",&x,&y);
     for(int i=; i<n; i++)
     {
         scanf("%lf%lf",&ps[i].x,&ps[i].y);
     }
     ps[n]=ps[];
 
     // 判断是否符合
     for(int i=; i<n; i++)
     {
         for(int j=; j<i-; j++)
         {
             if(isIntersected(ps[j],ps[j+],ps[i],ps[i+]))
             {
                 puts("NOFENCE");
                 exit();
             }
         }
     }
 
     vector<int> ans;
     for(int i=; i<n; i++)
     {
         if(check(i))
             ans.push_back(i);
     }
 
     int sz=ans.size();
     if(sz>= && ans[sz-]==n- && ans[sz-]==n-)
         swap(ans[sz-],ans[sz-]);
     printf("%d\n",sz);
     for(int i=; i<sz; i++)
     {
         if(ans[i]==n-)
             printf("%.0f %.0f %.0f %.0f\n",ps[ans[i]+].x,ps[ans[i]+].y,ps[ans[i]].x,ps[ans[i]].y);
         else
             printf("%.0f %.0f %.0f %.0f\n",ps[ans[i]].x,ps[ans[i]].y,ps[ans[i]+].x,ps[ans[i]+].y);
     }
 
     return ;
 }