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-8;
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) < 0 || sgn(a.x - b.x) == 0 && a.y < b.y;}
bool operator == (Point a, Point b) { return sgn(a.x - b.x) == 0 && sgn(a.y - b.y) == 0;}

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)) == 0 && sgn(dotDet(x, a, b)) < 0;}

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 > 0 && b_cd * d_ab > 0) return 1;
    if (onSeg(b, a, c) && c_da) return 2;
    if (onSeg(c, b, d) && d_ab) return 2;
    if (onSeg(d, c, a) && a_bc) return 2;
    if (onSeg(a, d, b) && b_cd) return 2;
    return 0;
}

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 = 0, sz = pt.size(); i < sz; i++) {
            ret += crossDet(pt[i], pt[(i + 1) % sz]);
        }
        return fabs(ret / 2.0);
    }
} ;

Poly cutPoly(Poly &poly, Point a, Point b) {
    Poly ret = Poly();
    int n = poly.size();
    for (int i = 0; i < n; i++) {
        Point c = poly[i], d = poly[(i + 1) % n];
        if (sgn(crossDet(a, b, c)) >= 0) ret.pt.push_back(c);
        if (sgn(crossDet(b - a, c - d)) != 0) {
            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 = 0, sz = poly.size(); i < sz; i++) {
        if (segIntersect(a, b, poly[i], poly[(i + 1) % 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) < 0) return 0;
    if (sgn(len) == 0) {
        sol.push_back(mid);
        return 1;
    }
    Vec dis = vecUnit(dir);
    len = sqrt(len);
    sol.push_back(mid + dis * len);
    sol.push_back(mid - dis * len);
    return 2;
}

bool segCircleIntersect(Point s, Point t, Circle C) {
    vector<Point> tmp;
    tmp.clear();
    if (lineCircleIntersect(s, t, C, tmp)) {
        if (tmp.size() < 2) return false;
        for (int i = 0, 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 = 0, sz = polies.size(); i < sz; i++) {
        Poly tmp;
        tmp = cutPoly(polies[i], s, t);
        if (tmp.size() >= 3 && tmp.area() > EPS) ret.push_back(tmp);
        tmp = cutPoly(polies[i], t, s);
        if (tmp.size() >= 3 && tmp.area() > EPS) ret.push_back(tmp);
    }
    return ret;
}

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

bool circlePoly(Circle C, Poly &poly) {
    int sz = poly.size();
    if (ptInPoly(C.c, poly)) return true;
//    cout << "~~ " << sz << endl;
    for (int i = 0; i < sz; i++) {
//        cout << poly[i].x << ' ' << poly[i].y << endl;
        if (inCircle(poly[i], C)) return true;
//        cout << i << endl;
    }
    for (int i = 0; i < sz; i++) {
        if (segCircleIntersect(poly[i], poly[(i + 1) % 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 = 0, sz = polies.size(); i < sz; i++) {
        if (circlePoly(C, polies[i])) ret.push_back(polies[i].area());
    }
    return ret;
}

const double dir[4][2] = { {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 = 0; i < 4; i++) {
            cur[0].pt.push_back(Point(L * dir[i][0], W * dir[i][1]));
        }
        Point p[2];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 2; j++) {
                cin >> p[j].x >> p[j].y;
            }
            cur = cutPolies(p[0], p[1], cur);
        }
//        cout << cur.size() << endl;
        Circle C = Circle();
        for (int i = 0; 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 = 0, sz = tmp.size(); j < sz; j++) {
                printf(" %.2f", tmp[j]);
            }
            cout << endl;
        }
        cout << endl;
    }
    return 0;
}

——written by Lyon