BZOJ2596 [Wc2007]疯狂赛车

写了一上午谁叫你智商低呢2333

Orz ydc虽然WC考跪了没进15人队

计算几何题真烦【摔

 

/**************************************************************
    Problem: 2596
    User: rausen
    Language: C++
    Result: Accepted
    Time:2256 ms
    Memory:159952 kb
****************************************************************/
 
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
 
using namespace std;
typedef double lf;
const lf eps = 1e-10;
const int N = 3000005;
 
inline int read() {
    int x = 0, sgn = 1;
    char ch = getchar();
    while (ch < '0' || '9' < ch) {
        if (ch == '-') sgn = -1;
        ch = getchar();
    }
    while ('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return sgn * x;
}
 
inline lf sqr(lf x) {
    return x * x;
}
 
inline int dcmp(lf x) {
    return fabs(x) <= eps ? 0 : (x > eps ? 1 : -1);
}
 
struct point {
    lf x, y;
    point() {}
    point(lf _x, lf _y) : x(_x), y(_y) {}
 
    inline point operator + (point p) {
        return point(x + p.x, y + p.y);
    }
    inline point operator - (point p) {
        return point(x - p.x, y - p.y);
    }
    inline lf operator * (point p) {
        return x * p.y - y * p.x;
    }
    inline lf operator % (point p) {
        return x * p.x + y * p.y;
    }
    inline point operator * (lf a) {
        return point(x * a, y * a);
    }
    inline point operator / (lf a) {
        return point(x / a, y / a);
    }
   
    inline bool operator < (const point &p) const {
        return dcmp(x - p.x) == 0 ? dcmp(y - p.y) < 0 : dcmp(x - p.x) < 0;
    }
    inline bool operator != (const point &p) const {
        return dcmp(x - p.x) || dcmp(y - p.y);
    }
    inline bool operator == (const point &p) const {
        return !dcmp(x - p.x) && !dcmp(y - p.y);
    }
   
    friend inline lf dis2(point p) {
        return sqr(p.x) + sqr(p.y);
    }
    friend inline lf dis(point p) {
        return sqrt(dis2(p));
    }
    friend inline lf dis(point p, point a, point b) {
        return fabs(((p - a) * (p - b)) / dis(b - a));
    }
    friend inline point projection(point p, point a, point b) {
        point c = b - a;
        lf t = -((a - p) % c) / (c % c);
        return a + c * t;
    }
    friend inline bool on_seg(point p, point a, point b) {
        return dcmp(p.x - a.x) * dcmp(p.x - b.x) <= 0 &&
            dcmp(p.y - a.y) * dcmp(p.y - b.y) <= 0;
    }
} p[N];
 
struct edge {
    int next, to;
    lf v;
    edge() {}
    edge(int _n, int _t, lf _v) : next(_n), to(_t), v(_v) {}
} e[N];
 
struct heap_node {
    lf v;
  int to;
  heap_node() {}
    heap_node(lf _v, int _t) : v(_v), to(_t) {}
 
    inline bool operator < (const heap_node &a) const {
        return v > a.v;
    }
};
 
int n, cnt;
lf va, vb, Dis[N];
int first[N], tot;
priority_queue <heap_node> h;
 
inline void add_edge(int x, int y, lf z) {
    e[++tot] = edge(first[x], y, z);
    first[x] = tot;
}
 
inline void Add_Edges(int x, int y, lf z) {
    add_edge(x, y, z);
    add_edge(y, x, z);
}
 
vector <point> E;
int pos[N];
 
void build_graph() {
    int i, j, id;
    lf H, D;
    point Pro, v, P, p1, p2;
    for (i = 1; i <= n; ++i) {
        E.clear();
        p1 = p[i], p2 = p[i + 1];
        for (j = 1; j <= n + 1; ++j)
            if (p[j] != p1 && p[j] != p2) {
                H = dis(p[j], p1, p2), D = vb * H / sqrt(sqr(va) - sqr(vb));
                Pro = projection(p[j], p1, p2), v = (p2 - p1) / dis(p2 - p1);
                P = Pro + v * D;
                if (on_seg(P, p1, p2)) E.push_back(P);
                P = Pro - v * D;
                if (on_seg(P, p1, p2)) E.push_back(P);
            }
 
        E.push_back(p1), E.push_back(p2);
        sort(E.begin(), E.end());
        int Cnt = unique(E.begin(), E.end()) - E.begin();
        if (E[0] == p1)
            pos[0] = i, pos[Cnt - 1] = i + 1;
        else
            pos[0] = i + 1, pos[Cnt - 1] = i;
        for (j = 1; j < Cnt - 1; ++j)
            pos[j] = ++cnt;
        for (j = 0; j < Cnt - 1; ++j)
            Add_Edges(pos[j], pos[j + 1], dis(E[j] - E[j + 1]) / va);
 
        for (j = 1; j <= n + 1; ++j)
            if (p[j] != p1 && p[j] != p2) {
                H = dis(p[j], p1, p2), D = vb * H / sqrt(sqr(va) - sqr(vb));
                Pro = projection(p[j], p1, p2), v = (p2 - p1) / dis(p2 - p1);
                P = Pro + v * D;
                if (on_seg(P, p1, p2)) {
                    id = lower_bound(E.begin(), E.end(), P) - E.begin();
                    Add_Edges(pos[id], j, dis(P - p[j]) / vb);
                }
                P = Pro - v * D;
                if (on_seg(P, p1, p2)) {
                    id = lower_bound(E.begin(), E.end(), P) - E.begin();
                    Add_Edges(pos[id], j, dis(P - p[j]) / vb);
                }
            }
    }
}
 
#define y e[x].to
inline void add_to_heap(int p) {
  int x;
  for (x = first[p]; x; x = e[x].next)
    if (!dcmp(Dis[y] + 1.0))
      h.push(heap_node(e[x].v + Dis[p], y));
}
#undef y
 
void Dijkstra(int S) {
    int p;
    for (p = 1; p <= cnt; ++p)
        Dis[p] = -1.0;
    while (!h.empty()) h.pop();
    Dis[S] = 0, add_to_heap(S);
    while (!h.empty()) {
        while (dcmp(Dis[h.top().to] + 1.0) && !h.empty()) h.pop();
        if (h.empty()) break;
        p = h.top().to;
        Dis[p] = h.top().v;
        if (p == n + 1) return;
        h.pop();
        add_to_heap(p);
    }
}
 
int main() {
    int i, j, x, y;
    n = read();
    scanf("%lf%lf", &va, &vb);
    p[1] = point(0, 0);
    for (i = 1; i <= n; ++i) {
        x = read(), y = read();
        p[i + 1] = point(x, y);
    }
    for (i = 1; i <= n + 1; ++i)
        for (j = 1; j <= n + 1; ++j)
            if (i != j)
                add_edge(i, j, dis(p[i] - p[j]) / vb);
    cnt = n + 1;
    build_graph();
    Dijkstra(1);
    printf("%lf\n", Dis[n + 1]);
    return 0;
}