uva 12304 2D Geometry 110 in 1! (Geometry)

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

　　新增加与圆有关的模板，过了这题。

　　使用模板的时候犯了一个小错误，忘记了自己的点到直线的距离是一个有向距离，结果就把自己坑了。

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

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); i++)

struct Point {
    double x, y;
    Point() {}
    Point(double x, double y) : x(x), y(y) {}
} ;
template<class T> T sqr(T x) { return x * x;}
inline double ptDis(Point a, Point b) { return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));}

// basic calculations
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);}

const double eps = 1e-8;
const double pi = acos(-1.0);
inline int sgn(double x) { return fabs(x) < eps ? 0 : (x < 0 ? -1 : 1);}
bool operator < (Point a, Point b) { return a.x < b.x || (a.x == b.x && 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 vecLen(Vec x) { return sqrt(sqr(x.x) + sqr(x.y));}
inline double angle(Vec v) { return atan2(v.y, v.x);}
inline double angle(Vec a, Vec b) { return acos(dotDet(a, b) / vecLen(a) / vecLen(b));}
inline double crossDet(Vec a, Vec b) { return a.x * b.y - a.y * b.x;}
inline double triArea(Point a, Point b, Point c) { return fabs(crossDet(b - a, c - a));}
inline Vec vecUnit(Vec x) { return x / vecLen(x);}
inline Vec rotate(Vec x, double rad) { return Vec(x.x * cos(rad) - x.y * sin(rad), x.x * sin(rad) + x.y * cos(rad));}
Vec normal(Vec x) {
    double len = vecLen(x);
    return Vec(- x.y / len, x.x / len);
}

struct Line {
    Point s, t;
    Line() {}
    Line(Point s, Point t) : s(s), t(t) {}
    Point point(double x) {
        return s + (t - s) * x;
    }
} ;
typedef Line Seg;

inline bool onSeg(Point x, Point a, Point b) { return sgn(crossDet(a - x, b - x)) == 0 && sgn(dotDet(a - x, b - x)) < 0;}
inline bool onSeg(Point x, Seg s) { return onSeg(x, s.s, s.t);}

// 0 : not intersect
// 1 : proper intersect
// 2 : improper intersect
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));
    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;
}
inline int segIntersect(Seg a, Seg b) { return segIntersect(a.s, a.t, b.s, b.t);}

// point of the intersection of 2 lines
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;
}
inline Point lineIntersect(Line a, Line b) { return lineIntersect(a.s, a.t - a.s, b.s, b.t - b.s);}

// Warning: This is a DIRECTED Distance!!!
double pt2Line(Point x, Point a, Point b) {
    Vec v1 = b - a, v2 = x - a;
    return crossDet(v1, v2) / vecLen(v1);
}
inline double pt2Line(Point x, Line L) { return pt2Line(x, L.s, L.t);}

double pt2Seg(Point x, Point a, Point b) {
    if (a == b) return vecLen(x - a);
    Vec v1 = b - a, v2 = x - a, v3 = x - b;
    if (sgn(dotDet(v1, v2)) < 0) return vecLen(v2);
    if (sgn(dotDet(v1, v3)) > 0) return vecLen(v3);
    return fabs(crossDet(v1, v2)) / vecLen(v1);
}
inline double pt2Seg(Point x, Seg s) { return pt2Seg(x, s.s, s.t);}

struct Poly {
    vector<Point> pt;
    Poly() {}
    Poly(vector<Point> pt) : pt(pt) {}
    double area() {
        double ret = 0.0;
        int sz = pt.size();
        for (int i = 1; i < sz; i++) {
            ret += crossDet(pt[i], pt[i - 1]);
        }
        return fabs(ret / 2.0);
    }
} ;

struct Circle {
    Point c;
    double r;
    Circle(Point c, double r) : c(c), r(r) {}
    Point point(double a) {
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
} ;

int lineCircleIntersect(Line L, Circle C, double &t1, double &t2, vector<Point> &sol) {
    double a = L.s.x, b = L.t.x - C.c.x, c = L.s.y, d = L.t.y - C.c.y;
    double e = sqr(a) + sqr(c), f = 2 * (a * b + c * d), g = sqr(b) + sqr(d) - sqr(C.r);
    double delta = sqr(f) - 4.0 * e * g;
    if (sgn(delta) < 0) return 0;
    if (sgn(delta) == 0) {
        t1 = t2 = -f / (2.0 * e);
        sol.push_back(L.point(t1));
        return 1;
    }
    t1 = (-f - sqrt(delta)) / (2.0 * e);
    sol.push_back(L.point(t1));
    t2 = (-f + sqrt(delta)) / (2.0 * e);
    sol.push_back(L.point(t2));
    return 2;
}

int lineCircleIntersect(Line L, Circle C, vector<Point> &sol) {
    Vec dir = L.t - L.s, nor = normal(dir);
    Point mid = lineIntersect(C.c, nor, L.s, dir);
    double len = sqr(C.r) - sqr(ptDis(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;
}

// -1 : coincide
int circleCircleIntersect(Circle C1, Circle C2, vector<Point> &sol) {
    double d = vecLen(C1.c - C2.c);
    if (sgn(d) == 0) {
        if (sgn(C1.r - C2.r) == 0) {
            return -1;
        }
        return 0;
    }
    if (sgn(C1.r + C2.r - d) < 0) return 0;
    if (sgn(fabs(C1.r - C2.r) - d) > 0) return 0;
    double a = angle(C2.c - C1.c);
    double da = acos((sqr(C1.r) + sqr(d) - sqr(C2.r)) / (2.0 * C1.r * d));
    Point p1 = C1.point(a - da), p2 = C1.point(a + da);
    sol.push_back(p1);
    if (p1 == p2) return 1;
    sol.push_back(p2);
    return 2;
}

int tangent(Point p, Circle C, vector<Vec> &sol) {
    Vec u = C.c - p;
    double dist = vecLen(u);
    if (dist < C.r) return 0;
    if (sgn(dist - C.r) == 0) {
        sol.push_back(rotate(u, pi / 2.0));
        return 1;
    }
    double ang = asin(C.r / dist);
    sol.push_back(rotate(u, -ang));
    sol.push_back(rotate(u, ang));
    return 2;
}

// ptA : points of tangency on circle A
// ptB : points of tangency on circle B
int tangent(Circle A, Circle B, vector<Point> &ptA, vector<Point> &ptB) {
    if (A.r < B.r) {
        swap(A, B);
        swap(ptA, ptB);
    }
    int d2 = sqr(A.c.x - B.c.x) + sqr(A.c.y - B.c.y);
    int rdiff = A.r - B.r, rsum = A.r + B.r;
    if (d2 < sqr(rdiff)) return 0;
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if (d2 == 0 && A.r == B.r) return -1;
    if (d2 == sqr(rdiff)) {
        ptA.push_back(A.point(base));
        ptB.push_back(B.point(base));
        return 1;
    }
    double ang = acos((A.r - B.r) / sqrt(d2));
    ptA.push_back(A.point(base + ang));
    ptB.push_back(B.point(base + ang));
    ptA.push_back(A.point(base - ang));
    ptB.push_back(B.point(base - ang));
    if (d2 == sqr(rsum)) {
        ptA.push_back(A.point(base));
        ptB.push_back(B.point(pi + base));
    } else if (d2 > sqr(rsum)) {
        ang = acos((A.r + B.r) / sqrt(d2));
        ptA.push_back(A.point(base + ang));
        ptB.push_back(B.point(pi + base + ang));
        ptA.push_back(A.point(base - ang));
        ptB.push_back(B.point(pi + base - ang));
    }
    return (int) ptA.size();
}

/****************** template above *******************/

const char *str[6] = { "CircumscribedCircle", "InscribedCircle", "TangentLineThroughPoint", "CircleThroughAPointAndTangentToALineWithRadius", "CircleTangentToTwoLinesWithRadius", "CircleTangentToTwoDisjointCirclesWithRadius"};
bool cmp(Circle x, Circle y) { return x.c < y.c || (x.c == y.c && x.r < y.r);}

Circle work1(Point p1, Point p2, Point p3) {
    Vec nor1 = normal(p1 - p2);
    Vec nor2 = normal(p2 - p3);
    Point mid1 = (p1 + p2) / 2.0;
    Point mid2 = (p2 + p3) / 2.0;
    Point O = lineIntersect(mid1, nor1, mid2, nor2);
    double r = ptDis(O, p1);
    return Circle(O, r);
}

Circle work2(Point p1, Point p2, Point p3) {
    Vec v11 = p2 - p1;
    Vec v12 = p3 - p1;
    Vec v21 = p1 - p2;
    Vec v22 = p3 - p2;
    double ang1 = (angle(v11) + angle(v12)) / 2.0;
    double ang2 = (angle(v21) + angle(v22)) / 2.0;
    Vec vec1 = Vec(cos(ang1), sin(ang1));
    Vec vec2 = Vec(cos(ang2), sin(ang2));
    Point O = lineIntersect(p1, vec1, p2, vec2);
    double r = pt2Line(O, p1, p2);
    return Circle(O, fabs(r));
}

vector<double> work3(Circle C, Point p) {
    vector<double> ret;
    vector<Vec> tmp;
    ret.clear();
    int cnt = tangent(p, C, tmp);
    for (int i = 0; i < cnt; i++) {
        double ang = angle(tmp[i]);
        if (ang < 0) ang += pi;
        ang = fmod(ang, pi);
        ret.push_back(ang * 180 / pi);
    }
    return ret;
}

vector<Point> work4(Point p, Line l, double r) {
    Vec vec = l.t - l.s;
    Vec nor = normal(vec);
    nor = nor / vecLen(nor) * r;
    vector<Point> ret;
    ret.clear();
    lineCircleIntersect(Line(l.s + nor, l.s + nor + vec), Circle(p, r), ret);
    lineCircleIntersect(Line(l.s - nor, l.s - nor + vec), Circle(p, r), ret);
    return ret;
}

vector<Point> work5(Line l1, Line l2, double r) {
    Vec v1 = l1.t - l1.s;
    Vec v2 = l2.t - l2.s;
    Vec nor1 = normal(v1);
    Vec nor2 = normal(v2);
    nor1 = nor1 / vecLen(nor1) * r;
    nor2 = nor2 / vecLen(nor2) * r;
    vector<Point> ret;
    ret.clear();
    ret.push_back(lineIntersect(l1.s + nor1, v1, l2.s + nor2, v2));
    ret.push_back(lineIntersect(l1.s + nor1, v1, l2.s - nor2, v2));
    ret.push_back(lineIntersect(l1.s - nor1, v1, l2.s + nor2, v2));
    ret.push_back(lineIntersect(l1.s - nor1, v1, l2.s - nor2, v2));
    return ret;
}

vector<Point> work6(Circle c1, Circle c2, double r) {
    c1.r += r;
    c2.r += r;
    vector<Point> ret;
    ret.clear();
    circleCircleIntersect(c1, c2, ret);
    return ret;
}

char buf[100];

int main() {
//    freopen("in", "r", stdin);
//    freopen("out", "w", stdout);
    double x[10];
    while (cin >> buf) {
        if (!strcmp(str[0], buf)) {
            for (int i = 0; i < 6; i++) {
                cin >> x[i];
            }
            Circle tmp = work1(Point(x[0], x[1]), Point(x[2], x[3]), Point(x[4], x[5]));
            printf("(%.6f,%.6f,%.6f)\n", tmp.c.x, tmp.c.y, tmp.r);
        } else if (!strcmp(str[1], buf)) {
            for (int i = 0; i < 6; i++) {
                cin >> x[i];
            }
            Circle tmp = work2(Point(x[0], x[1]), Point(x[2], x[3]), Point(x[4], x[5]));
            printf("(%.6f,%.6f,%.6f)\n", tmp.c.x, tmp.c.y, tmp.r);
        } else if (!strcmp(str[2] ,buf)) {
            for (int i = 0; i < 5; i++) {
                cin >> x[i];
            }
            vector<double> ans = work3(Circle(Point(x[0], x[1]), x[2]), Point(x[3], x[4]));
            sort(ans.begin(), ans.end());
            putchar('[');
            for (int i = 0; i < ans.size(); i++) {
                if (i) putchar(',');
                printf("%.6f", ans[i]);
            }
            puts("]");
        } else if (!strcmp(str[3], buf)) {
            for (int i = 0; i < 7; i++) {
                cin >> x[i];
            }
            vector<Point> ans = work4(Point(x[0], x[1]), Line(Point(x[2], x[3]), Point(x[4], x[5])), x[6]);
            sort(ans.begin(), ans.end());
            putchar('[');
            for (int i = 0; i < ans.size(); i++) {
                if (i) putchar(',');
                printf("(%.6f,%.6f)", ans[i].x, ans[i].y);
            }
            puts("]");
        } else if (!strcmp(str[4], buf)) {
            for (int i = 0; i < 9; i++) {
                cin >> x[i];
            }
            vector<Point> ans = work5(Line(Point(x[0], x[1]), Point(x[2], x[3])), Line(Point(x[4], x[5]), Point(x[6], x[7])), x[8]);
            sort(ans.begin(), ans.end());
            putchar('[');
            for (int i = 0; i < ans.size(); i++) {
                if (i) putchar(',');
                printf("(%.6f,%.6f)", ans[i].x, ans[i].y);
            }
            puts("]");
        } else if (!strcmp(str[5], buf)) {
            for (int i = 0; i < 7; i++) {
                cin >> x[i];
            }
            vector<Point> ans = work6(Circle(Point(x[0], x[1]), x[2]), Circle(Point(x[3], x[4]), x[5]), x[6]);
            sort(ans.begin(), ans.end());
            putchar('[');
            for (int i = 0; i < ans.size(); i++) {
                if (i) putchar(',');
                printf("(%.6f,%.6f)", ans[i].x, ans[i].y);
            }
            puts("]");
        }
    }
    return 0;
}

——written by Lyon