hdu 4063 Aircraft (Geometry + SP)

Problem - 4063

　　几何加简单最短路。

　　题意是给出若干圆的圆心以及半径，求出从给出的起点到终点的最短路径的长度，可以移动的区域是圆覆盖到的任意一个位置。

　　做法是这样的，对圆两两求交点，用这些得到的交点以及起点和终点作为我们要构造的图的顶点。因为我们要的是最短路径，所以如果我们要从一个区域穿越到另一区域的时候，必然是经过这些交点的。然后我们可以对这些交点两两判断是否能够相互到达。这个判断才是这道题的关键。判断的方法可以有几种，我想到的一是先求出直线与所有圆的交点，排序以后判断所有的圆能否覆盖掉这条线段；而我的是另一种方法，就是用一个队列，将还没有被覆盖的线段存在队列里，每次跟圆相交判断线段是否仍未被覆盖。

　　最后来一个单源最短路就搞掂了！

代码如下：

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

using namespace std;

const double EPS = 1e-10;
inline int sgn(double x) { return (x > EPS) - (x < -EPS);}
struct Point {
    double x, y;
    Point() {}
    Point(double x, double y) : x(x), y(y) {}
    bool operator < (Point a) const { return sgn(x - a.x) < 0 || sgn(x - a.x) == 0 && y < a.y;}
    bool operator <= (Point a) const { return (sgn(x - a.x) < 0 || sgn(x - a.x) == 0 && sgn(y - a.y) < 0) || (sgn(x - a.x) == 0 && sgn(y - a.y) == 0);}
    bool operator == (Point a) const { return sgn(x - a.x) == 0 && sgn(y - a.y) == 0;}
    void print() { cout << x << '~' << y << endl;}
} ;
template <class T> T sqr(T x) { return x * x;}
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 double dotDet(Vec a, Vec b) { return a.x * b.x + a.y * b.y;}
inline double dotDet(Point o, Point a, Point b) { return dotDet(a - o, b - o);}
inline double crossDet(Vec a, Vec b) { return a.x * b.y - a.y * b.x;}
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 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 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));}
inline Vec normal(Vec x) { return Vec(-x.y, x.x) / vecLen(x);}

struct Line {
    Point s, t;
    Line() {}
    Line(Point s, Point t) : s(s), t(t) {}
    Vec vec() { return t - s;}
    Point point(double x) { return s + vec() * 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);}

inline Point lineIntersect(Point P, Vec v, Point Q, Vec w) { return P + v * (crossDet(w, P - Q) / crossDet(v, w));}
inline Point lineIntersect(Line a, Line b) { return lineIntersect(a.s, a.vec(), b.s, b.vec());}

struct Circle {
    Point c;
    double r;
    Circle() {}
    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, vector<Point> &sol) {
    Vec nor = normal(L.vec());
    Point mid = lineIntersect(C.c, nor, L.s, L.vec());
    double len = sqr(C.r) - sqr(vecLen(C.c - mid));
    if (sgn(len) < 0) return 0;
    if (sgn(len) == 0) { sol.push_back(mid); return 1;}
    Vec dis = vecUnit(L.vec());
    len = sqrt(len);
    sol.push_back(mid + dis * len);
    sol.push_back(mid - dis * len);
    return 2;
}

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 -3 + (C1.r > C2.r);
    }
    if (sgn(C1.r + C2.r - d) < 0) return 0;
    if (sgn(fabs(C1.r - C2.r) - d) > 0) return -3 + (C1.r > C2.r);
    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);
//    p1.print();
    if (p1 == p2) return 1;
    sol.push_back(p2);
//    p2.print();
    return 2;
}

inline bool ptInCircle(Point p, Circle c) { return sgn(vecLen(c.c - p) - c.r) <= 0;}

const int N = 33;
Circle dev[N];
vector<Point> vex;
int sid, tid;
double mat[N * N][N * N];

Seg qseg[N * N];

double cal(int pi, int pj, int n) {
//    queue<Seg> seg;
    vector<Point> ip;
    int qh, qt;
    qh = qt = 0;
//    while (!seg.empty()) seg.pop();
    if (vex[pj] < vex[pi]) swap(pi, pj);
    Seg L = Seg(vex[pi], vex[pj]);
//    seg.push(L);
    qseg[qt++] = L;
    for (int i = 0; i < n; i++) {
//        int sz = seg.size();
        int sz = qt - qh;
        for (int j = 0; j < sz; j++) {
//            Seg tmp = seg.front();
//            seg.pop();
            Seg tmp = qseg[qh++];
//            if (pi == 0 && pj == 2) {
//                tmp.s.print();
//                tmp.t.print();
//                puts("tmp");
//            }
            ip.clear();
            if (lineCircleIntersect(L, dev[i], ip) == 2) {
                if (ip[1] < ip[0]) swap(ip[0], ip[1]);
//                if (pi == 0 && pj == 4) {
//                    ip[0].print();
//                    ip[1].print();
//                    puts("ip");
//                }
                if (ip[1] <= tmp.s || tmp.t <= ip[0])
//                    seg.push(tmp);
                    qseg[qt++] = tmp;
                else if (tmp.s <= ip[0] && ip[1] <= tmp.t) {
                    if (vecLen(tmp.s - ip[0]) > EPS)
//                        seg.push(Seg(tmp.s, ip[0]));
                        qseg[qt++] = Seg(tmp.s, ip[0]);
                    if (vecLen(tmp.t - ip[1]) > EPS)
//                        seg.push(Seg(ip[1], tmp.t));
                        qseg[qt++] = Seg(ip[1], tmp.t);
                } else if (tmp.s < ip[0] && ip[0] <= tmp.t && sgn(vecLen(tmp.s - ip[0])))
//                    seg.push(Seg(tmp.s, ip[0]));
                    qseg[qt++] = Seg(tmp.s, ip[0]);
                else if (tmp.s <= ip[1] && ip[1] < tmp.t && sgn(vecLen(ip[1] - tmp.t)))
//                    seg.push(Seg(ip[1], tmp.t));
                    qseg[qt++] = Seg(ip[1], tmp.t);
            } else
//                seg.push(tmp);
                qseg[qt++] = tmp;
        }
//        if (seg.size() == 0)
        if (qh == qt)
            return vecLen(vex[pi] - vex[pj]);
    }
    return -1.0;
}

void PRE(int n) {
    vex.clear();
    for (int i = 0; i < n; i++) {
        cin >> dev[i].c.x >> dev[i].c.y >> dev[i].r;
//        vex.push_back(dev[i].c);
    }
    vex.push_back(dev[0].c);
    vex.push_back(dev[n - 1].c);
    Point ps = dev[0].c, pt = dev[n - 1].c;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
//            cout << i << " = = " << j << endl;
            circleCircleIntersect(dev[i], dev[j], vex);
        }
    }
    sort(vex.begin(), vex.end());
    int t = (int) (unique(vex.begin(), vex.end()) - vex.begin());
    while (vex.size() > t) vex.pop_back();
//    cout << "size " << vex.size() << endl;
    for (int i = 0, sz = vex.size(); i < sz; i++) {
        if (vex[i] == ps) sid = i;
        if (vex[i] == pt) tid = i;
        for (int j = 0; j <= i; j++) {
            if (i == j) mat[i][j] = 0.0;
            else mat[i][j] = mat[j][i] = cal(i, j, n);
        }
    }
//    cout << sid << ' ' << tid << endl;
//    for (int i = 0, sz = vex.size(); i < sz; i++) {
//        vex[i].print();
//        for (int j = 0; j < sz; j++) printf("%7.4f ", mat[i][j]);
//        cout << endl;
//    }
}

const double FINF = 1e100;
double dis[N * N];
int q[N * N << 1];
double spfa() {
    int sz = vex.size();
//    queue<int> Q;
//    while (!Q.empty()) Q.pop();
    int qh, qt;
    qh = qt = 0;
    for (int i = 0; i < sz; i++) dis[i] = FINF;
    dis[sid] = 0.0;
//    Q.push(sid);
    q[qt++] = sid;
//    while (!Q.empty()) {
    while (qh < qt) {
//        int cur = Q.front();
//        Q.pop();
        int cur = q[qh++];
        for (int i = 0; i < sz; i++) {
            if (mat[cur][i] < 0) continue;
            if (dis[i] > dis[cur] + mat[cur][i]) {
                dis[i] = dis[cur] + mat[cur][i];
//                Q.push(i);
                q[qt++] = i;
            }
        }
    }
//    for (int i = 0; i < sz; i++) cout << dis[i] << ' '; cout << endl;
    return dis[tid];
}

int main() {
//    freopen("in", "r", stdin);
//    freopen("out", "w", stdout);
    int T, n;
    cin >> T;
    for (int cas = 1; cas <= T; cas++) {
        cin >> n;
        PRE(n);
        printf("Case %d: ", cas);
        double ans = spfa();
        if (ans < FINF) printf("%.4f
", ans);
        else puts("No such path.");
    }
    return 0;
}

附加自己出的数据：

8
2
0 0 1
2 0 1
2
0 0 1
4 1 2
3
-3 0 2
0 2 2
3 0 2
3
-3 0 2
0 3 3
3 0 2
6
-6 0 2
-3 0 2
0 3 3
3 0 2
7 0 2
0 8 2
10
-6 0 2
-3 0 2
0 3 3
3 0 2
7 0 2
0 8 2
-4 8 2
-8 8 2
-7 2 2
-8 4 2
3
0 10 7
-1 -1 100
10 0 7
3
-3 0 2
0 3 3
3 0 2

——written by Lyon