基础计算几何

POJ 1410 判断线段交和点在凸包内 

#include <cstdio>
#include <algorithm>
#include <cmath>
#define MP make_pair 
using namespace std;
typedef long long LL;


const double eps = 1e-8;

int sgn(double x) {
    if (fabs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}


struct Point {
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    }
    double operator *(const Point &b) const {
        return x * b.x + y * b.y;
    }
};

struct Line {
    Point s, e;
    Line(Point s, Point e): s(s), e(e) {}
};

bool SI(Line l1, Line l2) {
    return max(l1.s.x, l1.e.x) >= min(l2.s.x, l2.e.x)
        && max(l2.s.x, l2.e.x) >= min(l1.s.x, l1.e.x)
        && max(l1.s.y, l1.e.y) >= min(l2.s.y, l2.e.y)
        && max(l2.s.y, l2.e.y) >= min(l1.s.y, l1.e.y)
        && sgn((l2.s - l1.e) ^ (l1.s - l1.e)) * sgn((l2.e - l1.e) ^ (l1.s - l1.e)) <= 0 
        && sgn((l1.s - l2.e) ^ (l2.s - l2.e)) * sgn((l1.e - l2.e) ^ (l2.s - l2.e));
}

bool onSeg(Point P, Line L) {
    return sgn((L.s - P) ^ (L.e - P)) == 0
        && sgn((P.x - L.s.x) * (P.x - L.e.x)) <= 0
        && sgn((P.y - L.s.y) * (P.y - L.e.y)) <= 0;
}

int inConvexPoly(Point a, Point p[], int n) {
    for (int i = 0; i < n; i++) {
        if (sgn((p[i] - a) ^ (p[(i + 1) % n] - a)) < 0) return -1;
        else if (onSeg(a, Line(p[i], p[(i + 1) % n]))) return 0;
    }
    return 1;
}

int main() {
    int T;
    double x1, y1, x2, y2;
    scanf("%d", &T);
    while (T--) {
        scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
        Line line = Line(Point(x1, y1), Point(x2, y2));
        scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
        if (x1 > x2) swap(x1, x2);
        if (y1 > y2) swap(y1, y2);
        Point p[10];
        p[0] = Point(x1, y1);
        p[1] = Point(x2, y1);
        p[2] = Point(x2, y2);
        p[3] = Point(x1, y2);
        if (SI(line, Line(p[0], p[1]))) {puts("T"); continue;}
        if (SI(line, Line(p[1], p[2]))) {puts("T"); continue;}
        if (SI(line, Line(p[2], p[3]))) {puts("T"); continue;}
        if (SI(line, Line(p[3], p[0]))) {puts("T"); continue;}
        if (inConvexPoly(line.s, p, 4) >= 0 || inConvexPoly(line.e, p, 4) >= 0) {
            puts("T");
            continue;
        }
        puts("F");
    }

    return 0;
}

POJ 2546 求两圆的面积交

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;

const double eps = 1e-6;
const double pi = acos(-1.0);

struct Circle {
    double x, y;
    double r;
    Circle(double x = 0.0, double y = 0.0, double r = 1.0) : x(x), y(y), r(r) {}
};

double insectArea(Circle a, Circle b) {
    double dis = sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
    if (a.r + b.r <= dis) {
        return 0.0;
    } else if (fabs(a.r - b.r) >= dis) {
        return pi * min(a.r, b.r) * min(a.r, b.r);
    } else {
        double B1 = acos((a.r * a.r + dis * dis - b.r * b.r) / (2.0 * a.r * dis));
        double B2 = acos((b.r * b.r + dis * dis - a.r * a.r) / (2.0 * b.r * dis));
        return B1 * a.r * a.r + B2 * b.r * b.r - dis * a.r * sin(B1);
    }
}

int main() {
    double x, y, r;
    scanf("%lf%lf%lf", &x, &y, &r);
    Circle c1 = Circle(x, y, r);
    scanf("%lf%lf%lf", &x, &y, &r);
    Circle c2 = Circle(x, y, r);
    printf("%.3lf
", insectArea(c1, c2));
    return 0;
}

POJ 2187 对踵点对模板题

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long LL;

const double eps = 1e-6;
const int maxn = 5e4 + 10;

int n;
double x, y;

int sgn(double x) {
    if (fabs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}

struct Point {
    double x, y;
    Point(double x = 0, double y = 0): x(x), y(y) {}
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    } 
    double operator * (const Point &b) const {
        return x * b.x + y * b.y;
    }
};

bool cmp(const Point &a, const Point &b) {
    return sgn(a.x - b.x) == 0 ? (a.y < b.y) : (a.x < b.x);
}

double dist(Point a, Point b) {
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) ;
}

Point p[maxn], ch[maxn];

int ConvexHull() {
    sort(p, p + n, cmp);
    int m = 0;
    for (int i = 0; i < n; i++) {
        while (m > 1 && sgn((ch[m - 1] - ch[m - 2]) ^ (p[i] - ch[m - 2])) <= 0) m--;
        ch[m++] = p[i];
    }
    int k = m;
    for (int i = n - 2; i >= 0; i--) {
        while (m > k && sgn((ch[m - 1] - ch[m - 2]) ^ (p[i] - ch[m - 2])) <= 0) m--;
        ch[m++] = p[i];
    }
    if (n > 1) m--;
    return m;
}

void solve() {
    int m = ConvexHull();
    if (m == 2) {
        printf("%.0lf
", dist(ch[0], ch[1]));
    } else {
        int i = 0, j = 0;
        for (int k = 0; k < m; k++) {
            if (!cmp(ch[i], ch[k])) i = k;
            if (cmp(ch[j], ch[k])) j = k;
        }
        double res = 0.0;
        int si = i, sj = j;
        while (si != j || sj != i) {
            res = max(res, dist(ch[i], ch[j]));
            double tmp = (ch[(i + 1) % m] - ch[i]) ^ (ch[(j + 1) % m] - ch[j]);
            if (sgn(tmp) < 0) {
                i = (i + 1) % m;
            } else {
                j = (j + 1) % m;
            }
        }
        printf("%.0lf
", res);
    }
    
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%lf%lf", &x, &y);
        p[i].x = x; p[i].y = y;
    }
    solve();

    return 0;
}

POJ 1584 判断凸多边形，点在多边形内；计算点到线段距离(但事实上思考一下就会发现直接求点到直线距离即可)

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

typedef long long LL;

const double eps = 1e-8;
const double pi = acos(-1.0);

int sgn(double x) {
    if (fabs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}

struct Point {
    double x, y;
    Point(double x = 0.0, double y = 0.0): x(x), y(y) {}
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    }
    double operator * (const Point &b) const {
        return x * b.x + y * b.y;
    }
};

struct Line {
    Point s, e;
    Line() {}
    Line(Point s, Point e) : s(s), e(e) {}
};

double dist(Point a, Point b) {
    double t = (a - b) * (a - b);
    return sqrt(t);
}

bool isCH(Point poly[], int n) {
    bool s[3];
    s[0] = s[1] = s[2] = false;
    for (int i = 0; i < n; i++) {
        s[sgn((poly[(i + 1) % n] - poly[i]) ^ (poly[(i + 2) % n] - poly[i])) + 1] = true;
        if (s[0] && s[2]) return false;
    }
    return true;
}

Point PTS(Point P, Line L) {
    Point result;
    Point v = L.e - L.s;
    double t = (P - L.s) * v / (v * v);
//    if (t >= 0 && t <= 1) {
        result.x = L.s.x + t * v.x;
        result.y = L.s.y + t * v.y;
//    } else {
//        if (dist(P, L.s) < dist(P, L.e)) result = L.s;
//        else result = L.e;
//    }
    return result;
}

bool onSeg(Point P, Line L) {
    return sgn((L.s - P) ^ (L.e - P)) == 0
        && sgn((P.x - L.s.x) * (P.x - L.e.x)) <= 0
        && sgn((P.y - L.s.y) * (P.y - L.e.y)) <= 0;
}

int inCP(Point a, Point p[], int n) {
    for (int i = 0; i < n; i++) {
        if (sgn((p[i] - a) ^ (p[(i + 1) % n] - a)) < 0) return -1;
        else if (onSeg(a, Line(p[i], p[(i + 1) % n]))) return 0;
    }
    return 1;
}

bool inter(Line l1, Line l2) {
    return max(l1.s.x, l1.e.x) >= min(l2.s.x, l2.e.x) 
        && max(l2.s.x, l2.e.x) >= min(l1.s.x, l1.e.x)
        && max(l1.s.y, l1.e.y) >= min(l2.s.y, l2.e.y)
        && max(l2.s.y, l2.e.y) >= min(l1.s.y, l1.e.y)
        && sgn((l2.s - l1.e) ^ (l1.s - l1.e)) * sgn((l2.e - l1.e) ^ (l1.s - l1.e)) <= 0
        && sgn((l1.s - l2.e) ^ (l2.s - l2.e)) * sgn((l1.e - l2.e) ^ (l2.s - l2.e)) <= 0;
}

int inPoly(Point P, Point poly[], int n) {
    int cnt = 0;
    Line ray, side;
    ray.s = P;
    ray.e.y = P.y;
    ray.e.x = -100000000000.0;

    for (int i = 0; i < n; i++) {
        side.s = poly[i];
        side.e = poly[(i + 1) % n];

        if (onSeg(P,side)) return 0;
        if (sgn(side.s.y - side.e.y) == 0) continue;
        if(onSeg(side.s,ray)) {
            if(sgn(side.s.y - side.e.y) > 0) cnt++;
        } else if(onSeg(side.e,ray)) {
            if(sgn(side.e.y - side.s.y) > 0)cnt++;
        } else if(inter(ray,side)) {
            cnt++;
        }
    }
    if (cnt % 2 == 1) return 1;
    else return -1;
}


Point p[110];
int main() {
    int n;
    double R,x,y;
    while (scanf("%d",&n) == 1) {
        if (n < 3) break;
        scanf("%lf%lf%lf", &R, &x, &y);
        for (int i = 0; i < n; i++) {
            scanf("%lf%lf", &p[i].x, &p[i].y);
        }
        if (!isCH(p, n)) {
            puts("HOLE IS ILL-FORMED");
            continue;
        }
        Point P = Point(x, y);
        bool flag = true;
        if (inPoly(P, p, n) >= 0) {
            for (int i = 0; i < n && flag; i++) {
                if (sgn(dist(P, PTS(P, Line(p[i], p[(i + 1) % n]))) - R) < 0) {
                    flag = false;
                }
            }
        } else {
            flag = false;
        }
        if (flag) {
            puts("PEG WILL FIT");
        } else {
            puts("PEG WILL NOT FIT");
        }
    }
    return 0;
}

POJ 1873 枚举加凸包模板

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long LL;

const double eps = 1e-8;

int sgn(double x) {
    if (fabs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}

struct Point {
    double x, y, l;
    int v;
    Point(double x = 0.0, double y = 0.0) : x(x), y(y) {}
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    }
    double operator * (const Point &b) const {
        return x * b.x + y * b.y;
    }
};

bool cmp(const Point &a, const Point &b) {
    return sgn(a.x - b.x) == 0 ? (a.y < b.y) : (a.x < b.x);
}

double dist(Point a, Point b) {
    Point c = a - b;
    return sqrt(c * c);
}

Point p[20], ch[20];
Point pp[20];


int ConvexHull(int m) {
    sort(pp, pp + m, cmp);
    int num = 0;
    for (int i = 0; i < m; i++) {
        while (num > 1 && sgn((ch[num - 1] - ch[num - 2]) ^ (pp[i] - ch[num - 2])) <= 0) num--;
        ch[num++] = pp[i];
    }
    int k = num;
    for (int i = m - 2; i >= 0; i--) {
        while (num > k && sgn((ch[num - 1] - ch[num - 2]) ^ (pp[i] - ch[num - 2])) <= 0) num--;
        ch[num++] = pp[i];
    }
    if (m > 1) num--;
    return num;
}

int n;
int cnt;
double ans_l;
int ans_v, ans_c;

int ans;


void init() {
    ans = 0;
    ans_v = 200000.0;
    ans_l = 0.0;
    ans_c = 20;
}

void solve() {
    for (int bit = (1 << n) - 1; bit ; bit--) {
        int cnt = 0;
        double l = 0.0;
        double c = 0.0;
        int v = 0;
        for (int i = 0; i < n; i++) {
            if (bit & (1 << i)) {
                l += p[i].l;
                v += p[i].v;
            } else {
                pp[cnt++] = p[i];
            }
        }
        cnt = ConvexHull(cnt);

        for (int i = 0; i < cnt; i++) {
            c += dist(ch[i], ch[(i + 1) % cnt]);
        }
        bool flag = false;
        if (sgn(l - c) >= 0) {
            if (v < ans_v) {
                flag = true;
            } else if (v == ans_v) {
                if (cnt <= ans_c) flag = true;
            }
        }
        if (flag) {
            ans_v = v; ans_c = cnt;
            ans = bit;
            ans_l = l - c;
        }
    }
}

int main() {
    double x, y, l;
    int v;
    int te = 0;
    while (scanf("%d", &n), n) {
        init();
        for (int i = 0; i < n; i++) {
            scanf("%lf%lf%d%lf", &p[i].x, &p[i].y, &p[i].v, &p[i].l);
        }
        solve();
        printf("Forest %d
", ++te);
        printf("Cut these trees:");
        for (int i = 0; i < 15; i++) {
            if (ans & (1 << i)) {
                printf(" %d", i + 1);
            }
        }puts("");
        printf("Extra wood: %.2lf

", ans_l);
    }
    return 0;
}

HDU 3007 最小圆覆盖模板题

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long LL;

const double eps = 1e-6;

int sgn(double x) {
    if (fabs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}

struct Point {
    double x, y;
    Point(double x = 0.0, double y = 0.0) : x(x), y(y) {}
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }    
    Point operator + (const Point &b) const {
        return Point(x + b.x, y + b.y);
    }
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    }
    double operator * (const Point &b) const {
        return x * b.x + y * b.y;
    }
    Point operator / (double times) const {
        return Point(x / times, y / times);
    }
    Point operator * (double times) const {
        return Point(x * times, y * times);
    }
};

Point center;

Point outer(Point a, Point b, Point c) {
    double a1 = b.x - a.x, b1 = b.y - a.y, c1 = (a1 * a1 + b1 * b1) / 2;
    double a2 = c.x - a.x, b2 = c.y - a.y, c2 = (a2 * a2 + b2 * b2) / 2;
    double d = a1 * b2 - a2 * b1;
    return Point(a.x - (c2 * b1 - c1 * b2) / d, a.y + (a1 * c2 - a2 * c1) / d);
}

double dis(Point a, Point b) {
    return sqrt((a - b) * (a - b));
}

int n;

Point p[510];
double r;

void solve() {
    r = 0;
    center = p[0];
    for (int i = 1; i < n; i++) {
        if (sgn(dis(center, p[i]) - r) > 0) {
            center = p[i]; r = 0;
            for (int j = 0; j < i; j++) {
                if (sgn(dis(center, p[j]) - r) > 0) {
                    center = (p[i] + p[j]) / 2;
                    r = dis(p[i], center);
                    for (int k = 0; k < j; k++) {
                        if (sgn(dis(center, p[k]) - r) > 0) {
                            center = outer(p[i], p[j], p[k]);
                            r = dis(center, p[k]);
                        }
                    }
                }
            }
        }
    }
    printf("%.2lf %.2lf %.2lf
", center.x, center.y, r);
}

int main() {
    while (scanf("%d", &n), n) {
        for (int i = 0; i < n; i++) {
            scanf("%lf%lf", &p[i].x, &p[i].y);
        }
        solve();
    }
    return 0;
}

POJ 3568 求两个凸包间

#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long LL;

const double eps = 1e-6;
const int maxn = 1e4 + 10;
const double INF = 1e20;

int sgn(double x) {
    if (fabs(x) < eps) return 0;
    return x < 0 ? -1 : 1;
}

struct Point {
    double x, y;
    Point(double x = 0, double y = 0): x(x), y(y) {}
    Point operator - (const Point &b) const {
        return Point(x - b.x, y - b.y);
    }
    double operator * (const Point &b) const {
        return x * b.x + y * b.y;
    }
    double operator ^ (const Point &b) const {
        return x * b.y - y * b.x;
    }
};

bool cmp(const Point &a, const Point &b) {
    return sgn(a.x - b.x) == 0 ? (a.y < b.y) : (a.x < b.x);
}

double dist(Point a, Point b) {
    double t = (a - b) * (a - b);
    return sqrt(t);
}

struct Line {
    Point s, e;
    Line(Point s, Point e): s(s), e(e) {}
};

Point PST(Point P, Line l) {
    Point result;
    Point v = l.e - l.s;
    double t = (P - l.s) * v / (v * v);
    if (0 <= t && t <= 1) {
        result.x = l.s.x + t * v.x;
        result.y = l.s.y + t * v.y;
    } else {
        if (dist(P, l.s) < dist(P, l.e)) result = l.s;
        else result = l.e;
    }
    return result;
}

double _PTS(Point p0, Point p1, Point p2) {
    return dist(p0, PST(p0, Line(p1, p2)));
}

double STS(Point p0, Point p1, Point p2, Point p3) {
    double ans1 = min(_PTS(p0, p2, p3), _PTS(p1, p2, p3));
    double ans2 = min(_PTS(p2, p0, p1), _PTS(p3, p0, p1));
    return min(ans1, ans2);
}


int ConvexHull(Point pp[], int m, Point ch[]) {
    sort(pp, pp + m, cmp);
    int num = 0;
    for (int i = 0; i < m; i++) {
        while (num > 1 && sgn((ch[num - 1] - ch[num - 2]) ^ (pp[i] - ch[num - 2])) <= 0) num--;
        ch[num++] = pp[i];
    }
    int k = num;
    for (int i = m - 2; i >= 0; i--) {
        while (num > k && sgn((ch[num - 1] - ch[num - 2]) ^ (pp[i] - ch[num - 2])) <= 0) num--;
        ch[num++] = pp[i];
    }
    if (m > 1) num--;
    return num;
}


double getAngle(Point a1, Point a2, Point b1, Point b2) {
    return (a2 - a1) ^ (b1 - b2);
}

double rotating(Point *p, int np, Point *q, int nq) {
    int sp = 0, sq = 0;
    for (int i = 0; i < np; i++) {
        if (sgn(p[i].y - p[sp].y) < 0) sp = i;
    }
    for (int i = 0; i < nq; i++) {
        if (sgn(q[i].y - q[sq].y) > 0) sq = i;
    }
    double tmp;
    double ans = INF;

    for (int i = 0; i < np; i++) {
        while (sgn(tmp = getAngle(p[sp], p[(sp + 1) % np], q[sq], q[(sq + 1) % nq])) < 0) {
            sq = (sq + 1) % nq;
        }
        if (sgn(tmp) == 0) {
            ans = min(ans, STS(p[sp], p[(sp + 1) % np], q[sq], q[(sq + 1) % nq]));
        } else {
            ans = min(ans, _PTS(q[sq], p[sp], p[(sp + 1) % np]));
        }
        sp = (sp + 1) % np;
    }
    return ans;
}


Point p1[maxn], p2[maxn];
Point ch1[maxn], ch2[maxn];


double solve(Point *p, int n, Point *q, int m) {
    n = ConvexHull(p1, n, ch1);
    m = ConvexHull(p2, m, ch2);
    return min(rotating(ch1, n, ch2, m), rotating(ch2, m, ch1, n));
}

int main() {
    int n, m;
    while (scanf("%d%d", &n, &m), n && m) {
        for (int i = 0; i < n; i++) {
            scanf("%lf%lf", &p1[i].x, &p1[i].y);
        }
        for (int i = 0; i < m; i++) {
            scanf("%lf%lf", &p2[i].x, &p2[i].y);
        }
        double ans = solve(p1, n, p2, m);
        printf("%.5lf
", ans);
    }
    return 0;
}

POJ 1696 极角排序

POJ 1228 稳定凸包

POJ 3525 半平面交  求凸多边形内部点到边界最大距离

uva 4642 给出三角形三个顶点，求出三个圆的半径，三个圆满足两两相切且都与三角形相切

POJ 1981 问一个单位圆最多能覆盖多少个给出的点(n<=300)

HDU 6097 圆的反演基础题

uva 4676 给定两个三角形速度和顶点，求相撞时刻