uva 12296 Pieces and Discs （Geometry）

http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3717

　　暴力计算几何。 用切割多边形的方法，将初始的矩形划分成若干个多边形，然后对于每一个圆判断有哪些多边形是与其相交的。面积为0的多边形忽略。

　　对于多边形与圆相交，要主意圆在多边形内的情况。

代码如下：

 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <vector>
 #include <iostream>
 #include <algorithm>

 using namespace std;

 const double EPS = 1e-;
 const double PI = acos(-1.0);
 template <class T> T sqr(T x) { return x * x;}
 struct Point {
     double x, y;
     Point() {}
     Point(double x, double y) : x(x), y(y) {}
 } ;
 typedef Point Vec;
 Vec operator + (Vec a, Vec b) { return Vec(a.x + b.x, a.y + b.y);}
 Vec operator - (Vec a, Vec b) { return Vec(a.x - b.x, a.y - b.y);}
 Vec operator * (Vec a, double p) { return Vec(a.x * p, a.y * p);}
 Vec operator / (Vec a, double p) { return Vec(a.x / p, a.y / p);}
 inline int sgn(double x) { return (x > EPS) - (x < -EPS);}
 bool operator < (Point a, Point b) { return sgn(a.x - b.x) <  || sgn(a.x - b.x) ==  && a.y < b.y;}
 bool operator == (Point a, Point b) { return sgn(a.x - b.x) ==  && sgn(a.y - b.y) == ;}

 inline double dotDet(Vec a, Vec b) { return a.x * b.x + a.y * b.y;}
 inline double crossDet(Vec a, Vec b) { return a.x * b.y - a.y * b.x;}
 inline double dotDet(Point o, Point a, Point b) { return dotDet(a - o, b - o);}
 inline double crossDet(Point o, Point a, Point b) { return crossDet(a - o, b - o);}
 inline double vecLen(Vec x) { return sqrt(dotDet(x, x));}
 inline Vec vecUnit(Vec x) { return x / vecLen(x);}
 inline Vec normal(Vec x) { return Vec(-x.y, x.x) / vecLen(x);}
 inline bool onSeg(Point x, Point a, Point b) { return sgn(crossDet(x, a, b)) ==  && sgn(dotDet(x, a, b)) < ;}

 int segIntersect(Point a, Point c, Point b, Point d) {
     Vec v1 = b - a, v2 = c - b, v3 = d - c, v4 = a - d;
     int a_bc = sgn(crossDet(v1, v2));
     int b_cd = sgn(crossDet(v2, v3));
     int c_da = sgn(crossDet(v3, v4));
     int d_ab = sgn(crossDet(v4, v1));
 //    cout << a_bc << ' ' << b_cd << ' ' << c_da << ' ' << d_ab << endl;
     if (a_bc * c_da >  && b_cd * d_ab > ) return ;
     if (onSeg(b, a, c) && c_da) return ;
     if (onSeg(c, b, d) && d_ab) return ;
     if (onSeg(d, c, a) && a_bc) return ;
     if (onSeg(a, d, b) && b_cd) return ;
     return ;
 }

 Point lineIntersect(Point P, Vec v, Point Q, Vec w) {
     Vec u = P - Q;
     double t = crossDet(w, u) / crossDet(v, w);
     return P + v * t;
 }

 struct Poly {
     vector<Point> pt;
     Poly() { pt.clear();}
     ~Poly() {}
     Poly(vector<Point> &pt) : pt(pt) {}
     Point operator [] (int x) const { return pt[x];}
     int size() { return pt.size();}
     double area() {
         double ret = 0.0;
         for (int i = , sz = pt.size(); i < sz; i++) {
             ret += crossDet(pt[i], pt[(i + ) % sz]);
         }
         return fabs(ret / 2.0);
     }
 } ;

 Poly cutPoly(Poly &poly, Point a, Point b) {
     Poly ret = Poly();
     int n = poly.size();
     for (int i = ; i < n; i++) {
         Point c = poly[i], d = poly[(i + ) % n];
         if (sgn(crossDet(a, b, c)) >= ) ret.pt.push_back(c);
         if (sgn(crossDet(b - a, c - d)) != ) {
             Point ip = lineIntersect(a, b - a, c, d - c);
             if (onSeg(ip, c, d)) ret.pt.push_back(ip);
         }
     }
     return ret;
 }

 bool isIntersect(Point a, Point b, Poly &poly) {
     for (int i = , sz = poly.size(); i < sz; i++) {
         if (segIntersect(a, b, poly[i], poly[(i + ) % sz])) return true;
     }
     return false;
 }

 struct Circle {
     Point c;
     double r;
     Circle() {}
     Circle(Point c, double r) : c(c), r(r) {}
 } ;

 inline bool inCircle(Point a, Circle c) { return vecLen(c.c - a) < c.r;}
 bool lineCircleIntersect(Point s, Point t, Circle C, vector<Point> &sol) {
     Vec dir = t - s, nor = normal(dir);
     Point mid = lineIntersect(C.c, nor, s, dir);
     double len = sqr(C.r) - dotDet(C.c - mid, C.c - mid);
     if (sgn(len) < ) return ;
     if (sgn(len) == ) {
         sol.push_back(mid);
         return ;
     }
     Vec dis = vecUnit(dir);
     len = sqrt(len);
     sol.push_back(mid + dis * len);
     sol.push_back(mid - dis * len);
     return ;
 }

 bool segCircleIntersect(Point s, Point t, Circle C) {
     vector<Point> tmp;
     tmp.clear();
     if (lineCircleIntersect(s, t, C, tmp)) {
         if (tmp.size() < ) return false;
         for (int i = , sz = tmp.size(); i < sz; i++) {
             if (onSeg(tmp[i], s, t)) return true;
         }
     }
     return false;
 }

 vector<Poly> cutPolies(Point s, Point t, vector<Poly> polies) {
     vector<Poly> ret;
     ret.clear();
     for (int i = , sz = polies.size(); i < sz; i++) {
         Poly tmp;
         tmp = cutPoly(polies[i], s, t);
         if (tmp.size() >=  && tmp.area() > EPS) ret.push_back(tmp);
         tmp = cutPoly(polies[i], t, s);
         if (tmp.size() >=  && tmp.area() > EPS) ret.push_back(tmp);
     }
     return ret;
 }

 int ptInPoly(Point p, Poly &poly) {
     int wn = , sz = poly.size();
     for (int i = ; i < sz; i++) {
         if (onSeg(p, poly[i], poly[(i + ) % sz])) return -;
         int k = sgn(crossDet(poly[(i + ) % sz] - poly[i], p - poly[i]));
         int d1 = sgn(poly[i].y - p.y);
         int d2 = sgn(poly[(i + ) % sz].y - p.y);
         if (k >  && d1 <=  && d2 > ) wn++;
         if (k <  && d2 <=  && d1 > ) wn--;
     }
     if (wn != ) return ;
     return ;
 }

 bool circlePoly(Circle C, Poly &poly) {
     int sz = poly.size();
     if (ptInPoly(C.c, poly)) return true;
 //    cout << "~~ " << sz << endl;
     for (int i = ; i < sz; i++) {
 //        cout << poly[i].x << ' ' << poly[i].y << endl;
         if (inCircle(poly[i], C)) return true;
 //        cout << i << endl;
     }
     for (int i = ; i < sz; i++) {
         if (segCircleIntersect(poly[i], poly[(i + ) % sz], C)) return true;
 //        cout << i << endl;
     }
     return false;
 }

 vector<double> circlePolies(Circle C, vector<Poly> &polies) {
     vector<double> ret;
     ret.clear();
     for (int i = , sz = polies.size(); i < sz; i++) {
         if (circlePoly(C, polies[i])) ret.push_back(polies[i].area());
     }
     return ret;
 }

 const double dir[][] = { {0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}, {0.0, 1.0}};

 int main() {
 //    freopen("in", "r", stdin);
 //    freopen("out", "w", stdout);
     double L, W;
     int n, m;
     while (cin >> n >> m >> L >> W && (n + m + L + W > EPS)) {
         vector<Poly> cur;
         cur.push_back(Poly());
         for (int i = ; i < ; i++) {
             cur[].pt.push_back(Point(L * dir[i][], W * dir[i][]));
         }
         Point p[];
         for (int i = ; i < n; i++) {
             for (int j = ; j < ; j++) {
                 cin >> p[j].x >> p[j].y;
             }
             cur = cutPolies(p[], p[], cur);
         }
 //        cout << cur.size() << endl;
         Circle C = Circle();
         for (int i = ; i < m; i++) {
             cin >> C.c.x >> C.c.y >> C.r;
             vector<double> tmp = circlePolies(C, cur);
             sort(tmp.begin(), tmp.end());
             cout << tmp.size();
             for (int j = , sz = tmp.size(); j < sz; j++) {
                 printf(" %.2f", tmp[j]);
             }
             cout << endl;
         }
         cout << endl;
     }
     return ;
 }

——written by Lyon