2017 Multi-University Training Contest - Team 9 1003&&HDU 6163 CSGO【计算几何】

CSGO

Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 127    Accepted Submission(s): 20

Problem Description

Senior
Pan is crazy about CSGO and she is so skilled. She can kill every enemy
she spots at the same time, even if they are in different positions.
There
are some walls in a map. The locations of enemies are represented by
some points and walls are represented by some line segments in the XY
plane. The position of senior Pan is also described as a point. Senior
Pan can spot an enemy if and only if the segment between them doesn’t
intersect with any wall segment. But if there are other enemies on this
segment, she can kill all of them.
For some given positions, senior
Pan wants to know how many enemies she can kill in these positions. Your
Task is to write a program to figure it out.

 

Input

∙ The input contains multiple test cases, each of them are described below.
∙
The first line contains three integers N, M, Q representing
respectively the number of enemies, the number of walls and the number
of positions senior Pan chooses. For the next N lines, each line contain
two integers X and Y, indicating the location of enemies is (X, Y). The
next M lines, each line contain four integers X1, Y1, X2, Y2,
indicating two endpoints of the wall are (X1, Y1) and (X2, Y2). The last
Q lines, each line contain two integers X and Y, indicating the
location of senior Pan chooses is (X, Y).
∙
You can assume that walls don’t intersect even if in their endpoints,
no enemies have the same location and no enemies are in walls.
∙ N, M <= 10 ^ 4.
∙ Q <= 12.
∙ -10 ^ 6 <= X, Y, X1, Y1, X2, Y2 <= 10 ^ 6

 

Output

For each test case, output "Case #x: " in the first line (without quotes).
For
next Q lines, each line output a number which represents the number of
enemies senior Pan can kill in her i-th chosen location.

 

Sample Input

3 2 1
1 1
2 2
-1 1
0 1 -1 0
2 -2 2 0
0 0
5 4 2
29 -8
19 33
-46 -44
-38 19
9 -20
40 45 38 18
9 -32 -8 46
33 20 35 -19
22 17 -5 40
19 -38
-17 -21

Sample Output

Case #1:
2
Case #2:
3
2

Source

2017 Multi-University Training Contest - Team 9

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6163

分析：
平面上有一些点和一些线段，保证这些线段互不相交，点不在线段上。
每次问从一个点能看到多少个点。一个点能看到另一点当且仅当这两点连线的线段不和任何一个已知的线段相交。（这里的相交均指非规范相交）
每次以询问点为极点极角排序。线段两端点拆成两个事件，一次出现，一次消失。对于枚举的某一个角度，能否看见当前角度的点仅取决于当前角度上离极点最近的线段，由于保证线段不相交，一条线段在插入时和还存在线段的相对位置是不会改变的，所以可以用set维护，每次先处理当前角度上所有的点是否被线段遮挡就可以了。

复杂度是O（Q(N
+ M)log(N + M)）。

下面给出AC代码：

 #include<bits/stdc++.h>

 using namespace std;
 const int N = ;
 const double eps = 1e-;
 const double pi = acos(-1.0);
 typedef complex<double> Point;

 double Det(const Point & a, const Point & b) {return (conj(a) * b).imag();}
 double Dot(const Point & a, const Point & b) {return (conj(a) * b).real();}
 int sgn(double x) {if(fabs(x) < eps) return ; if(x > eps) return ; return -;}

 double _ang;
 Point ori = (Point) {, };
 struct Line :public vector<Point>{
     double k;
     Line(){}
     Line(Point a, Point b){
         push_back(a), push_back(b);
         k = atan2((b - a).imag(), (b - a).real());
     }
 };
 Point Vec(Line a) {return a[] - a[];}
 Point LineIntersection(const Line & a, const Line & b){
     double k1 = Det(Vec(a), Vec(b));
     double k2 = Det(Vec(b), a[] - b[]);
     if(!sgn(k1)){
         if(sgn(abs(a[] - b[]) - abs(a[] - b[])) > ) return a[];
         else return a[];
     }
     return a[] + Vec(a) * k2 / k1;
 }

 bool operator < (const Line & a, const Line & b){
     Line cur = (Line) {ori, (Point) {cos(_ang), sin(_ang)}};
     if(sgn(abs(LineIntersection(a, cur)) - abs(LineIntersection(b, cur))) < ) return ;
     return ;
 }

 struct Event{
     double k;
     int id, typ;
     bool operator < (const Event & a) const{
         if(sgn(k - a.k)) return k < a.k;
         return typ < a.typ;
     }
 };

 double CalcAng(const Point & a) {return atan2(a.imag(), a.real());}
 Point p[N];
 Line w[N], seg[N];
 Event e[N << ];

 int q, n, m, tot;
 set<Line> s;
 int rec[N];

 int Calc(int x){
     tot = ;
     s.clear();
     for(int i = ; i <= n; i ++)
         e[++ tot] = (Event){CalcAng(p[i] - p[x]), i, };

     bool flag = ;
     for(int i = ; i <= m; i++){
         seg[i] = (Line) {w[i][] - p[x], w[i][] - p[x]};
         if(sgn(CalcAng(seg[i][]) - CalcAng(seg[i][])) > ) swap(seg[i][], seg[i][]);
         flag = ;
         if(sgn(Det(Vec(seg[i]), Point(-, ))) !=  && sgn(abs(CalcAng(seg[i][]) - CalcAng(seg[i][])) - pi) > ) flag = ;
         if(flag) e[++ tot] = (Event) {CalcAng(seg[i][]), i, }, e[++tot] = (Event) {CalcAng(seg[i][]), i, };
         else{
             e[++ tot] = (Event) {-pi, i, };
             e[++ tot] = (Event) {CalcAng(seg[i][]), i, };
             e[++ tot] = (Event) {CalcAng(seg[i][]), i, };
             e[++ tot] = (Event) {pi, i, };
         }
     }

     sort(e + , e + tot + );
     int cnt = ;
     Point dir, dd;
     Line t;
     for(int i = ; i <= tot; i ++){
         _ang = e[i].k;
         if(e[i].typ & ){
             dir = (Point) {cos(_ang), sin(_ang)};
             if(s.empty() || sgn(abs(LineIntersection(*s.begin(), (Line) {ori, dir})) - abs(p[e[i].id] - p[x])) > ){
                 cnt ++, rec[cnt] = e[i].id;
             }
         }
         else if(!e[i].typ) s.insert(seg[e[i].id]);
         else s.erase(seg[e[i].id]);
     }

     return cnt;
 }

 int Tcase;

 char fi[] = "pcx.in", fo[] = "pcx.ans";
 void Solve(){
     printf("Case #%d:\n", ++ Tcase);
     double x, y;
     Point a, b;
     for(int i = ; i <= n; i ++){
         scanf("%lf%lf", &x, &y);
         p[i] = (Point) {x, y};
     }
     for(int i = ; i <= m; i ++){
         scanf("%lf%lf", &x, &y);
         a = (Point) {x, y};
         scanf("%lf%lf", &x, &y);
         b = (Point) {x, y};
         w[i] = (Line) {a, b};
     } 

     int ans;
     for(int i = ; i <= q; i ++){
         scanf("%lf%lf", &x, &y);
         p[n + ] = (Point) {x, y};
         ans = Calc(n + );
         printf("%d\n", ans);
     }

     return;
 }

 int main(){
 //    freopen("_pc.in", "r", stdin);
 //    freopen("_pc.ans", "w", stdout);
     while(~scanf("%d%d%d", &n, &m, &q))
         Solve();
     //printf("--->%lf\n", (double) clock() / CLOCKS_PER_SEC);
     return ;
 }