POJ 2540 Hotter Colder（半平面交）

Description

The children's game Hotter Colder is played as follows. Player A leaves the room while player B hides an object somewhere in the room. Player A re-enters at position (0,0) and then visits various other positions about the room. When player A visits a new position, player B announces "Hotter" if this position is closer to the object than the previous position; player B announces "Colder" if it is farther and "Same" if it is the same distance.

Input

Input consists of up to 50 lines, each containing an x,y coordinate pair followed by "Hotter", "Colder", or "Same". Each pair represents a position within the room, which may be assumed to be a square with opposite corners at (0,0) and (10,10).

Output

For each line of input print a line giving the total area of the region in which the object may have been placed, to 2 decimal places. If there is no such region, output 0.00.

 

题目大意：在一个大小为10*10，左下角为(0,0)的正方形上有一个位置不明的物体。初始点的(0,0)，每次选择一个点，如果这个点比前一个的点离不明物体近了，就是Hotter，远了就是Colder，一样就是Same。问不明物体可能出现的面积有多大。

思路：初始化4个半平面为10*10的正方形的四条边向内的半平面。每一次询问，可以得到一个半平面（对于这个半平面的选择，可以让当前点与前一个点绕他们的中点旋转90度得到）。那么这些半平面的面积交就是答案。由于数据比较小，每次询问都求一次半平面交问题也不是很大。

 

代码（0MS）：

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <cmath>
 using namespace std;

 const int MAXN = ;
 const double EPS = 1e-;
 const double PI = acos(-1.0);//3.14159265358979323846

 inline int sgn(double x) {
     return (x > EPS) - (x < -EPS);
 }

 struct Point {
     double x, y, ag;
     Point() {}
     Point(double x, double y): x(x), y(y) {}
     void read() {
         scanf("%lf%lf", &x, &y);
     }
     bool operator == (const Point &rhs) const {
         return sgn(x - rhs.x) ==  && sgn(y - rhs.y) == ;
     }
     bool operator < (const Point &rhs) const {
         if(y != rhs.y) return y < rhs.y;
         return x < rhs.x;
     }
     Point operator + (const Point &rhs) const {
         return Point(x + rhs.x, y + rhs.y);
     }
     Point operator - (const Point &rhs) const {
         return Point(x - rhs.x, y - rhs.y);
     }
     Point operator * (const int &b) const {
         return Point(x * b, y * b);
     }
     Point operator / (const int &b) const {
         return Point(x / b, y / b);
     }
     double length() const {
         return sqrt(x * x + y * y);
     }
     Point unit() const {
         return *this / length();
     }
 };
 typedef Point Vector;

 double dist(const Point &a, const Point &b) {
     return (a - b).length();
 }

 double cross(const Point &a, const Point &b) {
     return a.x * b.y - a.y * b.x;
 }
 //ret >= 0 means turn left
 double cross(const Point &sp, const Point &ed, const Point &op) {
     return sgn(cross(sp - op, ed - op));
 }

 double area(const Point& a, const Point &b, const Point &c) {
     return fabs(cross(a - c, b - c)) / ;
 }
 //counter-clockwise
 Point rotate(const Point &p, double angle, const Point &o = Point(, )) {
     Point t = p - o;
     double x = t.x * cos(angle) - t.y * sin(angle);
     double y = t.y * cos(angle) + t.x * sin(angle);
     return Point(x, y) + o;
 }

 struct Seg {
     Point st, ed;
     double ag;
     Seg() {}
     Seg(Point st, Point ed): st(st), ed(ed) {}
     void read() {
         st.read(); ed.read();
     }
     void makeAg() {
         ag = atan2(ed.y - st.y, ed.x - st.x);
     }
 };
 typedef Seg Line;

 void moveRight(Line &v, double r) {
     double dx = v.ed.x - v.st.x, dy = v.ed.y - v.st.y;
     dx = dx / dist(v.st, v.ed) * r;
     dy = dy / dist(v.st, v.ed) * r;
     v.st.x += dy; v.ed.x += dy;
     v.st.y -= dx; v.ed.y -= dx;
 }

 bool isOnSeg(const Seg &s, const Point &p) {
     return (p == s.st || p == s.ed) ||
         (((p.x - s.st.x) * (p.x - s.ed.x) <  ||
           (p.y - s.st.y) * (p.y - s.ed.y) < ) &&
          sgn(cross(s.ed, p, s.st) == ));
 }

 bool isIntersected(const Point &s1, const Point &e1, const Point &s2, const Point &e2) {
     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)) &&
         (cross(s2, e1, s1) * cross(e1, e2, s1) >= ) &&
         (cross(s1, e2, s2) * cross(e2, e1, s2) >= );
 }

 bool isIntersected(const Seg &a, const Seg &b) {
     return isIntersected(a.st, a.ed, b.st, b.ed);
 }

 bool isParallel(const Seg &a, const Seg &b) {
     return sgn(cross(a.ed - a.st, b.ed - b.st)) == ;
 }

 //return Ax + By + C =0 's A, B, C
 void Coefficient(const Line &L, double &A, double &B, double &C) {
     A = L.ed.y - L.st.y;
     B = L.st.x - L.ed.x;
     C = L.ed.x * L.st.y - L.st.x * L.ed.y;
 }
 //point of intersection
 Point operator * (const Line &a, const Line &b) {
     double A1, B1, C1;
     double A2, B2, C2;
     Coefficient(a, A1, B1, C1);
     Coefficient(b, A2, B2, C2);
     Point I;
     I.x = - (B2 * C1 - B1 * C2) / (A1 * B2 - A2 * B1);
     I.y =   (A2 * C1 - A1 * C2) / (A1 * B2 - A2 * B1);
     return I;
 }

 bool isEqual(const Line &a, const Line &b) {
     double A1, B1, C1;
     double A2, B2, C2;
     Coefficient(a, A1, B1, C1);
     Coefficient(b, A2, B2, C2);
     return sgn(A1 * B2 - A2 * B1) ==  && sgn(A1 * C2 - A2 * C1) ==  && sgn(B1 * C2 - B2 * C1) == ;
 }

 struct Poly {
     int n;
     Point p[MAXN];//p[n] = p[0]
     void init(Point *pp, int nn) {
         n = nn;
         for(int i = ; i < n; ++i) p[i] = pp[i];
         p[n] = p[];
     }
     double area() {
         if(n < ) return ;
         double s = p[].y * (p[n - ].x - p[].x);
         for(int i = ; i < n; ++i)
             s += p[i].y * (p[i - ].x - p[i + ].x);
         return s / ;
     }
 };

 void Graham_scan(Point *p, int n, int *stk, int &top) {//stk[0] = stk[top]
     sort(p, p + n);
     top = ;
     stk[] = ; stk[] = ;
     for(int i = ; i < n; ++i) {
         while(top && cross(p[i], p[stk[top]], p[stk[top - ]]) >= ) --top;
         stk[++top] = i;
     }
     int len = top;
     stk[++top] = n - ;
     for(int i = n - ; i >= ; --i) {
         while(top != len && cross(p[i], p[stk[top]], p[stk[top - ]]) >= ) --top;
         stk[++top] = i;
     }
 }
 //use for half_planes_cross
 bool cmpAg(const Line &a, const Line &b) {
     if(sgn(a.ag - b.ag) == )
         return sgn(cross(b.ed, a.st, b.st)) < ;
     return a.ag < b.ag;
 }
 //clockwise, plane is on the right
 bool half_planes_cross(Line *v, int vn, Poly &res, Line *deq) {
     int i, n;
     sort(v, v + vn, cmpAg);
     for(i = n = ; i < vn; ++i) {
         if(sgn(v[i].ag - v[i-].ag) == ) continue;
         v[n++] = v[i];
     }
     int head = , tail = ;
     deq[] = v[], deq[] = v[];
     for(i = ; i < n; ++i) {
         if(isParallel(deq[tail - ], deq[tail]) || isParallel(deq[head], deq[head + ]))
             return false;
         while(head < tail && sgn(cross(v[i].ed, deq[tail - ] * deq[tail], v[i].st)) > )
             --tail;
         while(head < tail && sgn(cross(v[i].ed, deq[head] * deq[head + ], v[i].st)) > )
             ++head;
         deq[++tail] = v[i];
     }
     while(head < tail && sgn(cross(deq[head].ed, deq[tail - ] * deq[tail], deq[head].st)) > )
         --tail;
     while(head < tail && sgn(cross(deq[tail].ed, deq[head] * deq[head + ], deq[tail].st)) > )
         ++head;
     if(tail <= head + ) return false;
     res.n = ;
     for(i = head; i < tail; ++i)
         res.p[res.n++] = deq[i] * deq[i + ];
     res.p[res.n++] = deq[head] * deq[tail];
     res.n = unique(res.p, res.p + res.n) - res.p;
     res.p[res.n] = res.p[];
     return true;
 }

 /*******************************************************************************************/

 Poly poly;
 Line line[MAXN], deq[MAXN];
 char str[];
 Point pre, cur;
 int n;

 int main() {
     line[n++] = Line(Point(, ), Point(, )); line[n - ].makeAg();
     line[n++] = Line(Point(, ), Point(, )); line[n - ].makeAg();
     line[n++] = Line(Point(, ), Point(, )); line[n - ].makeAg();
     line[n++] = Line(Point(, ), Point(, )); line[n - ].makeAg();
     pre = Point(, );
     double x, y;
     while(scanf("%lf%lf%s", &x, &y, str) != EOF) {
         cur = Point(x, y);
         Point mid = (cur + pre) / ;
         if(strcmp(str, "Hotter")) {
             Point st = rotate(pre, -PI/, mid);
             Point ed = rotate(cur, -PI/, mid);
             line[n++] = Line(st, ed); line[n - ].makeAg();
         }
         if(strcmp(str, "Colder")) {
             Point st = rotate(pre, PI/, mid);
             Point ed = rotate(cur, PI/, mid);
             line[n++] = Line(st, ed); line[n - ].makeAg();
         }
         bool flag = half_planes_cross(line, n, poly, deq);
         printf("%.2f\n", flag * (poly.area() + EPS));
         pre = cur;
     }
 }