[代码]ural 1913 Titan Ruins: Old Generators Are Fine Too

Abstract

ural 1913 Titan Ruins: Old Generators Are Fine Too

implementation 几何 圆交

Source

http://acm.timus.ru/problem.aspx?space=1&num=1913

Solution

主要思路就是判断距离到某两个点是r，另一个点是2r的点。

比赛时候用三分乱搞，大概是被卡了精度还是什么的，没有通过。

赛后用圆交重写了一遍，一开始还是没通过。

然后发现自己的圆交模板是针对面积问题的，单点的情况没有考虑清楚，乱改的时候改错了。大致就是处理圆覆盖的情况时，在预处理统计时算被覆盖了一次，在算两圆交点的时候又被统计了一次。还是没弄熟悉圆交的原理所致。

Code

#include <iostream>

#include <cassert>

#include <cmath>

#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;



const double EPS = 1e-8;

const double PI = acos(-1.0);



inline int sgn(double x) {

    if (fabs(x)<EPS) return 0;

    return x>0?1:-1;

}



struct sp {

    double x, y;

    double pa;

    int cnt;

    sp() {}

    sp(double a, double b): x(a), y(b) {}

    sp(double a, double b, double c, int d): x(a), y(b), pa(c), cnt(d) {}

    bool operator<(const sp &rhs) const {

        if (sgn(pa-rhs.pa)==0) return cnt>rhs.cnt;

        return pa<rhs.pa;

    }

    void read() {scanf("%lf%lf", &x, &y);}

    void write() {printf("%.10f %.10f\n", x, y);}

}t, s1, s2, p[5], e[20];

double r, rad[5];

int cover[5];



sp operator*(double d, const sp &v) {

    return sp(d*v.x, d*v.y);

}



sp operator-(const sp &u, const sp &v) {

    return sp(u.x-v.x, u.y-v.y);

}



sp operator+(const sp &u, const sp &v) {

    return sp(u.x+v.x, u.y+v.y);

}



double dot(const sp &u, const sp &v) {

    return u.x*v.x+u.y*v.y;

}



double det(const sp &u, const sp &v) {

    return u.x*v.y-u.y*v.x;

}



double dis(const sp &u, const sp &v) {

    double dx = u.x-v.x;

    double dy = u.y-v.y;

    return sqrt(dx*dx+dy*dy);

}



double dissqr(const sp &u, const sp &v) {

    double dx = u.x-v.x;

    double dy = u.y-v.y;

    return dx*dx+dy*dy;

}



void write(sp u, sp v) {

    puts("Now we have enough power");

    u.write(); v.write();

}



bool cirint(const sp &u, double ru, const sp &v, double rv, sp &a, sp &b) {

    double d = dis(u, v);

    if (sgn(d-(ru+rv))>0 || sgn(d-fabs(ru-rv))<=0) return 0;

    sp c = u-v;

    double ca, sa, cb, sb, csum, ssum;



    ca = c.x/d, sa = c.y/d;

    cb = (rv*rv+d*d-ru*ru)/(2*rv*d), sb = sqrt(1-cb*cb);

    csum = ca*cb-sa*sb;

    ssum = sa*cb+sb*ca;

    a = sp(rv*csum, rv*ssum);

    a = a+v;



    sb = -sb;

    csum = ca*cb-sa*sb;

    ssum = sa*cb+sb*ca;

    b = sp(rv*csum, rv*ssum);

    b = b+v;



    return 1;

}



bool cu(int N, sp p[], double r[], sp &res) {

    int i, j, k;

    memset(cover, 0, sizeof cover);

    for (i = 0; i < N; ++i)

        for (j = 0; j < N; ++j) {

            double rd = r[i]-r[j];

            if (i!=j && sgn(rd)>0 && sgn(dis(p[i], p[j])-rd)<=0)

                cover[j]++;

        }

    sp a, b;

    for (i = 0; i < N; ++i) {

        int ecnt = 0;

        e[ecnt++] = sp(p[i].x-r[i], p[i].y, -PI, 1);

        e[ecnt++] = sp(p[i].x-r[i], p[i].y, PI, -1);

        for (j = 0; j < N; ++j) {

            if (j==i) continue;

            if (cirint(p[i], r[i], p[j], r[j], a, b)) {

                e[ecnt++] = sp(a.x, a.y, atan2(a.y-p[i].y, a.x-p[i].x), 1);

                e[ecnt++] = sp(b.x, b.y, atan2(b.y-p[i].y, b.x-p[i].x), -1);

                if (sgn(e[ecnt-2].pa-e[ecnt-1].pa)>0) {

                    e[0].cnt++;

                    e[1].cnt--;

                }

            }

        }

        sort(e, e+ecnt);

        int cnt = e[0].cnt;

        for (j = 1; j < ecnt; ++j) {

            if (cover[i]+cnt==N) {

                double a = (e[j].pa+e[j-1].pa)/2;

                res = p[i]+sp(r[i]*cos(a), r[i]*sin(a));

                return 1;

            }

            cnt += e[j].cnt;

        }

    }

    return 0;

}



bool solve(const sp &o, const sp &u, const sp &v, double r) {

    p[0] = o, rad[0] = r+r;

    p[1] = u; p[2] = v; rad[1] = rad[2] = r;

    sp a, b;

    if (cu(3, p, rad, a)) {

        b = 0.5*(a-o);

        b = o+b;

        write(a, b);

        return 1;

    }

    else return 0;

}



int main() {

    cin>>r;

    t.read(); s1.read(); s2.read();

    sp a, b, c, d;

    if (cirint(s1, r, s2, r, a, b)) {

        if (solve(t, s1, s2, r)) return 0;

    }

    else {

        if (cirint(s1, r, t, r, a, b) && cirint(s2, r, t, r, c, d)) {

            write(a, c);

            return 0;

        }

        else {

            if (solve(s1, t, s2, r)) return 0;

            if (solve(s2, t, s1, r)) return 0;

        }

    }

    puts("Death");

    return 0;

}

顺便贴圆交模板，这回的应该没问题了。

#include <cmath>

#include <algorithm>

using namespace std;



const double PI = acos(-1.0);

const double EPS = 1e-8;



int sgn(double d) {

    if (fabs(d)<EPS) return 0;

    return d>0?1:-1;

}



struct sp {

    double x, y;

    double pa;

    int cnt;

    sp() {}

    sp(double a, double b): x(a), y(b) {}

    sp(double a, double b, double c, int d): x(a), y(b), pa(c), cnt(d) {}

    bool operator<(const sp &rhs) const {

        /* 需要处理单点的情况时

        if (sgn(pa-rhs.pa)==0) return cnt>rhs.cnt;

        */

        return pa<rhs.pa;

    }

    void read() {scanf("%lf%lf", &x, &y);}

    void write() {printf("%lf %lf\n", x, y);}

};



sp operator+(const sp &u, const sp &v) {

    return sp(u.x+v.x, u.y+v.y);

}



sp operator-(const sp &u, const sp &v) {

    return sp(u.x-v.x, u.y-v.y);

}



double det(const sp &u, const sp &v) {

    return u.x*v.y-v.x*u.y;

}



double dir(const sp &p, const sp &u, const sp &v) {

    return det(u-p, v-p);

}



double dis(const sp &u, const sp &v) {

    double dx = u.x-v.x;

    double dy = u.y-v.y;

    return sqrt(dx*dx+dy*dy);

}



//计算两圆交点

//输入圆心坐标和半径

//返回两圆是否相交(相切不算)

//如果相交，交点返回在a和b(从a到b为u的交弧)

bool cirint(const sp &u, double ru, const sp &v, double rv, sp &a, sp &b) {

    double d = dis(u, v);

    /* 需要处理单点的情况时 覆盖的情况在这里不统计

    if (sgn(d-(ru+rv))>0 || sgn(d-fabs(ru-rv))<=0) return 0;

    */

    if (sgn(d-(ru+rv))>=0 || sgn(d-fabs(ru-rv))<=0) return 0;

    sp c = u-v;

    double ca, sa, cb, sb, csum, ssum;



    ca = c.x/d, sa = c.y/d;

    cb = (rv*rv+d*d-ru*ru)/(2*rv*d), sb = sqrt(1-cb*cb);

    csum = ca*cb-sa*sb;

    ssum = sa*cb+sb*ca;

    a = sp(rv*csum, rv*ssum);

    a = a+v;



    sb = -sb;

    csum = ca*cb-sa*sb;

    ssum = sa*cb+sb*ca;

    b = sp(rv*csum, rv*ssum);

    b = b+v;



    return 1;

}



sp e[222];

int cover[111];



//求圆并

//输入点数N，圆心数组p，半径数组r，答案数组s

//s[i]表示被至少i个圆覆盖的面积(最普通的圆并就是s[1])

void circle_union(int N, sp p[], double r[], double s[]) {

    int i, j, k;

    memset(cover, 0, sizeof cover);

    for (i = 0; i < N; ++i)

        for (j = 0; j < N; ++j) {

            double rd = r[i]-r[j];

            //覆盖的情况在这里统计

            if (i!=j && sgn(rd)>0 && sgn(dis(p[i], p[j])-rd)<=0)

                cover[j]++;

        }

    for (i = 0; i < N; ++i) {

        int ecnt = 0;

        e[ecnt++] = sp(p[i].x-r[i], p[i].y, -PI, 1);

        e[ecnt++] = sp(p[i].x-r[i], p[i].y, PI, -1);

        for (j = 0; j < N; ++j) {

            if (j==i) continue;

            if (cirint(p[i], r[i], p[j], r[j], a, b)) {

                e[ecnt++] = sp(a.x, a.y, atan2(a.y-p[i].y, a.x-p[i].x), 1);

                e[ecnt++] = sp(b.x, b.y, atan2(b.y-p[i].y, b.x-p[i].x), -1);

                if (sgn(e[ecnt-2].pa-e[ecnt-1].pa)>0) {

                    e[0].cnt++;

                    e[1].cnt--;

                }

            }

        }

        sort(e, e+ecnt);

        int cnt = e[0].cnt;

        for (j = 1; j < ecnt; ++j) {

            double pad = e[j].pa-e[j-1].pa;

            s[cover[i]+cnt] += (det(e[j-1], e[j])+r[i]*r[i]*(pad-sin(pad)))/2;

            cnt += e[j].cnt;

        }

    }

}