USACO: 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)

13
5 5
0 0
7 0
5 2
7 5
5 7
3 5
4 9
1 8
2 5
0 9
-2 7
0 3
-3 1 

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)

7
0 0 7 0
5 2 7 5
7 5 5 7
5 7 3 5
-2 7 0 3
0 0 -3 1
0 3 -3 1
 

解题思路：

考完试终于可以回来刷题啦，一回来就遇到大怪，这道计算几何真是让我死掉了不少脑细胞

看了一些题解，觉得都不太靠谱，还是自己写吧

首先定义线段类，使用标准式定义，并保存下两个端点，以及观察者对两个端点的视角，视角用单链表是因为取(-pi, pi]，视角可能存在“两段”：

[-pi, a1]∪[a2, pi]

beColline检查两段线段是共线并存在交集，一个版本用来检查相邻的线段（有一个公共点），另一个版本则是非相邻的，比较繁琐

beCrossed检查非共线线段是否有交点，使用了text里面讲的跨立实验，因为已经算出来标准式，所以这个判断变得很简单（试试用斜率式写，判断特殊情况会烦死你）

getCovered用来做交叠：首先看两段线段的覆盖视角是否有一个公共角，存在的话，看看在公共角范围内哪个线段离观察者近，远的那条就会被它覆盖掉这个角度。

怎样判断远近呢？我使用的是参数方程，取公共部分中央角度，以观察者为源点，参数t的绝对值就是距离

以上各步骤完成后检查real（真正可以被看到的角度范围）即可

这样做最大的优点是什么呢？角度能够保存的精确信息比点多得多，也就是说，可以不用考虑误差什么的了。

看看效率如何，听说最近新增了几个刁难的数据，不过我没栽在这上面：

USER: Geterns Liu [geterns1]
TASK: fence4
LANG: C++

Compiling...
Compile: OK

Executing...
   Test 1: TEST OK [0.011 secs, 2940 KB]
   Test 2: TEST OK [0.000 secs, 2940 KB]
   Test 3: TEST OK [0.000 secs, 2940 KB]
   Test 4: TEST OK [0.000 secs, 2940 KB]
   Test 5: TEST OK [0.011 secs, 2940 KB]
   Test 6: TEST OK [0.000 secs, 2940 KB]
   Test 7: TEST OK [0.011 secs, 2940 KB]
   Test 8: TEST OK [0.022 secs, 2940 KB]
   Test 9: TEST OK [0.011 secs, 2940 KB]
   Test 10: TEST OK [0.022 secs, 2940 KB]
   Test 11: TEST OK [0.000 secs, 2940 KB]
   Test 12: TEST OK [0.011 secs, 2940 KB]

/*
ID: geterns1
PROG: fence4
LANG: C++
*/
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;

const int size = 200;
const double pi = 2 * asin(double(1));	//pi
struct point{ double x, y; };	//a point defined by Cartesian Coordinates
struct range{
	double a1, a2; range *next;
	range(){ next = NULL; }
};
//the initial data
point points[size];
double angle[size];
range list[10 * size]; int cnt = 0;
//class define
double k, l, m;
class segment{
private:
	point p1, p2;	//two endpoints
	range *total, *real;	//two angles
	double a, b, c;	//general form: ax + by - c = 0
public:
	static point observer;	//the observer
	//build by initial data
	void build(int idx1, int idx2){
		//low index first
		if (idx1 < idx2){
			p1 = points[idx1]; p2 = points[idx2];
		}
		else{
			p1 = points[idx2]; p2 = points[idx1];
		}
		//
		total = list + cnt ++;
		total->next = list + cnt ++;
		real = list + cnt ++;
		real->next = list + cnt ++;
		if (angle[idx1] < angle[idx2]){
			if (angle[idx2] - angle[idx1] < pi){
				total->next->a1 = angle[idx1];
				total->next->a2 = angle[idx2];
				real->next->a1 = angle[idx1];
				real->next->a2 = angle[idx2];
			}
			else{
				total->next->a1 = -pi;
				total->next->a2 = angle[idx1];
				total->next->next = list + cnt ++;
				total->next->next->a1 = angle[idx2];
				total->next->next->a2 = pi;
				real->next->a1 = -pi;
				real->next->a2 = angle[idx1];
				real->next->next = list + cnt ++;
				real->next->next->a1 = angle[idx2];
				real->next->next->a2 = pi;
			}
		}
		else{
			if (angle[idx1] - angle[idx2] < pi){
				total->next->a1 = angle[idx2]; 
				total->next->a2 = angle[idx1];
				real->next->a1 = angle[idx2]; 
				real->next->a2 = angle[idx1];
			}
			else{
				total->next->a1 = -pi;
				total->next->a2 = angle[idx2];
				total->next->next = list + cnt ++;
				total->next->next->a1 = angle[idx1];
				total->next->next->a2 = pi;
				real->next->a1 = -pi;
				real->next->a2 = angle[idx2];
				real->next->next = list + cnt ++;
				real->next->next->a1 = angle[idx1];
				real->next->next->a2 = pi;
			}
		}
		//
		a = p2.y - p1.y;
		b = p1.x - p2.x;
		c = a * p1.x + b * p1.y;
	}
	//print
	void print(){
		printf("%.0lf %.0lf %.0lf %.0lf/n", p1.x, p1.y, p2.x, p2.y);
	}
	//
	double pointSide(point &op){ return a * op.x + b * op.y - c; }
	bool angleDist(double ag, double &ds){
		k = cos(ag); l = sin(ag); m = a * k + b * l;
		if (m == 0) return false;
		ds = abs((c - a * observer.x - b * observer.y) / m);
		return true;
	}
	bool isvisible(){ return (real->next != NULL && real->next->a1 != real->next->a2); }
	//
	friend bool beColline(segment &sg1, segment &sg2, point &common, point &pt1, point &pt2);
	friend int beColline(segment &sg1, segment &sg2);
	friend bool beCrossed(segment &sg1, segment &sg2);
	friend void getCovered(segment &sg1, segment &sg2);
};
point segment::observer;	//outside define
double xup, xlow, yup, ylow;
bool beColline(segment &sg1, segment &sg2, point &common, point &pt1, point &pt2){
	if (sg1.pointSide(pt2) == 0 && sg2.pointSide(pt1) == 0){
		//
		if (pt1.x > pt2.x){ xup = pt1.x; xlow = pt2.x; }
		else{ xup = pt2.x; xlow = pt1.x; }
		if (pt1.y > pt2.y){ yup = pt1.y; ylow = pt2.y; }
		else{ yup = pt2.y; ylow = pt1.y; }
		//
		if (common.x > xup || common.x < xlow || common.y > yup || common.y < ylow)
			return true;
	}
	return false;
}
double xup1, xup2, xlow1, xlow2, ylow1, yup1, ylow2, yup2;
int beColline(segment &sg1, segment &sg2){
	if (sg1.pointSide(sg2.p1) == 0 && sg1.pointSide(sg2.p2) == 0
		&& sg2.pointSide(sg1.p1) == 0 && sg2.pointSide(sg1.p2) == 0){
		if (sg1.p1.x < sg1.p2.x){ xlow1 = sg1.p1.x; xup1 = sg1.p2.x; }
		else{ xlow1 = sg1.p2.x; xup1 = sg1.p1.x; }
		if (sg1.p1.y < sg1.p2.y){ ylow1 = sg1.p1.y; yup1 = sg1.p2.y; }
		else{ ylow1 = sg1.p2.y; yup1 = sg1.p1.y; }
		if (sg2.p1.x < sg2.p2.x){ xlow2 = sg2.p1.x; xup2 = sg2.p2.x; }
		else{ xlow2 = sg2.p2.x; xup2 = sg2.p1.x; }
		if (sg2.p1.y < sg2.p2.y){ ylow2 = sg2.p1.y; yup2 = sg2.p2.y; }
		else{ ylow2 = sg2.p2.y; yup2 = sg2.p1.y; }
		if (xlow1 > xup2 || xlow2 > xup1 || ylow1 > yup2 || ylow2 > ylow1)
			return 0;
		return 1;
	}
	return -1;
}
int re;
bool beCrossed(segment &sg1, segment &sg2){
	re = beColline(sg1, sg2);
	if (re >= 0) return re > 0;
	if (sg1.pointSide(sg2.p1) * sg1.pointSide(sg2.p2) > 0)
		return false;
	if (sg2.pointSide(sg1.p1) * sg2.pointSide(sg1.p2) > 0)
		return false;
	return true;
}
double c1, c2, mc, d1, d2; range *scn1, *scn2, *scn3;
void getCovered(segment &sg1, segment &sg2){
	scn1 = sg1.total;
	while (scn1->next != NULL){
		scn2 = sg2.total;
		while (scn2->next != NULL){
			//get common angle
			c1 = (scn1->next->a1 > scn2->next->a1 ? scn1->next->a1 : scn2->next->a1);
			c2 = (scn1->next->a2 < scn2->next->a2 ? scn1->next->a2 : scn2->next->a2);
			//a specil check
			if (c1 >= c2){
				scn2 = scn2->next;
				continue;
			}
			//cover it!
			mc = (c1 + c2) / 2;
			sg1.angleDist(mc, d1);
			sg2.angleDist(mc, d2);
			if (d1 < d2)
				scn3 = sg2.real;
			else scn3 = sg1.real;
			//
			while(scn3->next != NULL){
				if (c1 >= scn3->next->a2 || c2 <= scn3->next->a1)
					scn3 = scn3->next;
				else if (c1 <= scn3->next->a1 && c2 >= scn3->next->a2)
					scn3->next = scn3->next->next;
				else if (c1 > scn3->next->a1 && c2 < scn3->next->a2){
					list[cnt].a1 = c2;
					list[cnt].a2 = scn3->next->a2;
					list[cnt].next = scn3->next->next;
					scn3->next->a2 = c1;
					scn3->next->next = list + cnt ++;
					scn3 = scn3->next->next;
				}
				else if (c1 > scn3->next->a1){
					scn3->next->a2 = c1;
					scn3 = scn3->next;
				}
				else{
					scn3->next->a1 = c2;
					break;
				}
			}
			scn2 = scn2->next;
		}
		scn1 = scn1->next;
	}
}
//get angle of the observer
double dx, dy, r, a;
double getAngle(point p){
	dx = p.x - segment::observer.x;
	dy = p.y - segment::observer.y;
	r = sqrt(dx * dx + dy * dy);
	a = asin(dy / r);
	if (dx < 0){
		if (dy < 0) a = -pi - a;
		else a = pi - a;
	}
	return a;
}
//
int n;
inline int pre(int idx){
	if (idx == 0) return n - 1;
	return idx - 1;
}
inline int nxt(int idx){
	if (idx == n - 1) return 0;
	return idx + 1;
}
//
segment S[size];
//
int main(){
	freopen("fence4.in", "r", stdin);
	freopen("fence4.out", "w", stdout);

	//
	scanf("%d/n", &n);
	scanf("%lf %lf/n", &segment::observer.x, &segment::observer.y);
	for (int i = 0; i < n; i ++){
		scanf("%lf %lf/n", &points[i].x, &points[i].y);
		angle[i] = getAngle(points[i]);
	}
	for (int i = 0; i < n; i ++)
		S[i].build(i, nxt(i));
	//check
	for (int i = 0; i < n; i ++){
		if (beColline(S[i], S[nxt(i)], points[nxt(i)], points[i], points[nxt(nxt(i))])){
			printf("NOFENCE/n");
			return 0;
		}
		for (int j = i + 2; j < n; j ++){
			if (j != pre(i) && beCrossed(S[i], S[j])){
				printf("NOFENCE/n");
				return 0;
			}
		}
	}
	//
	for (int i = 0; i < n; i ++)
		for (int j = i + 1; j < n; j ++)
			getCovered(S[i], S[j]);
	//
	int queue[size], c = 0;
	for (int i = 0; i < n; i ++)
		if (S[i].isvisible())
			queue[c ++] = i;
	if (queue[c - 1] == n - 1 && queue[c - 2] == n - 2)
		swap(queue[c - 1], queue[c -2]);
	printf("%d/n", c);
	for (int i = 0; i < c; i ++)
		S[queue[i]].print();

	fclose(stdin);
	fclose(stdout);

	return 0;
}