BZOJ 1020 安全的航线

1020: [SHOI2008]安全的航线flight

Time Limit: 5 Sec  Memory Limit: 162 MB
Submit: 1462  Solved: 503
[Submit][Status][Discuss]

Description

　　在设计航线的时候，安全是一个很重要的问题。首先，最重要的是应采取一切措施确保飞行不会发生任何事故
，但同时也需要做好最坏的打算，一旦事故发生，就要确保乘客有尽量高的生还几率。当飞机迫降到海上的时候，
最近的陆地就是一个关键的因素。航线中最危险的地方就是距离最近的陆地最远的地方，我们称这种点为这条航线
“孤地点”。孤地点到最近陆地的距离被称为“孤地距离”。作为航空公司的高级顾问，你接受的第一个任务就是
尽量找出一条航线的孤地点，并计算这条航线的孤地距离。为了简化问题，我们认为地图是一个二维平面，陆地可
以用多边形近似，飞行线路为一条折线。航线的起点和终点都在陆地上，但中间的转折点是可能在海上（如下图所
示，方格标示出了孤地点）。

Input

　　输入的第一行包括两个整数C和N（1≤C≤20，2≤N≤20），分别代表陆地的数目的航线的转折点的数目。接下
来有N行，每行有两个整数x,y。(x,y)表示一个航线转折点的坐标，第一个转折点为航线的起点，最后一个转折点
为航线的终点。接下来的输入将用来描述C块大陆。每块输入由一个正整数M开始（M≤30），M表示多边形的顶点个
数，接下来的M行，每行会包含两个整数x,y，(x,y)表示多边形的一个顶点坐标，我们保证这些顶点以顺时针或逆
时针给出了该多边形的闭包，不会出现某些边相交的情况。此外我们也保证输入数据中任何两块大陆不会相交。输
入的所有坐标将保证在-10000到10000的范围之间。

Output

　　输出一个浮点数，表示航线的孤地距离，数据保留2位小数。

Sample Input

1 2
-9 -6
5 1
3
0 16
-16 -12
17 -6

Sample Output

0.00

HINT

 

Source

NWERC 2007

思路：用个队列存储所有要处理的线段。对每截线段分别求出端点s距多边形的最近点a和t的最近点b，用sa和tb更新答案，在s、t之间找到p使得pa = pb，易知st上所有点对答案的贡献都不超过pa，由此在此处剪枝。

如剪不掉，将两截子线段都加入队列中。

代码：

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define pli pair<ll, int>
#define pil pair<int, ll>
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define TREE tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update>
TREE T;
*/

int sgn(double x) {return x < -EPS ? -1 : (x < EPS ? 0 : 1);}
struct Point {
    double x, y;
    Point () {}
    Point (double x, double y) : x(x), y(y) {}
    Point operator + (const Point &p) const {return Point(x + p.x, y + p.y);}
    Point operator - (const Point &p) const {return Point(x - p.x, y - p.y);}
    Point operator * (const double &k) const {return Point(x * k, y * k);}
    Point operator / (const double &k) const {return Point(x / k, y / k);}
    double operator ^ (const Point &p) const {return x * p.y - y * p.x;}
    double operator | (const Point &p) const {return x * p.x + y * p.y;}
    bool operator < (const Point &p) const {return sgn(x - p.x) ? x < p.x : y < p.y;}
    double len2() {return x * x + y * y;}
    double len() {return sqrt(len2());}
    void input() {scanf("%lf%lf", &x, &y);}
    void output() {printf("%.6f %.6f
", x, y);}
} p[205];
#define pdp pair<double, Point>
struct Line {
    Point s, e;
    Line () {}
    Line (Point s, Point e) : s(s), e(e) {}
    Point operator & (const Line &l) const {
        double k1 = (l.s - s) ^ (l.e - s);
        double k2 = (l.e - e) ^ (l.s - e);
        return (s * k2 + e * k1) / (k1 + k2);
    }
    bool operator | (const Point &p) const {// now on line but not seg
        double x1 = min(s.x, e.x), x2 = max(s.x, e.x);
        double y1 = min(s.y, e.y), y2 = max(s.y, e.y);
        return 0 <= sgn(p.x - x1) && 0 <= sgn(x2 - p.x) && 
                0 <= sgn(p.y - y1) && 0 <= sgn(y2 - p.y);
    }
    pdp dis(Point p) {
        if (0 < ((p - s) | (e - s)) && ((p - s) | (e - s)) < (e - s).len2()) {
               return pdp(fabs((p - s) ^ (e - s)) / (e - s).len(), s + (e - s) * ((p - s) | (e - s)) / (e - s).len2());
        } else {
            double ds = (p - s).len(), de = (p - e).len();
            if (ds < de) {
                return pdp(ds, s);
            } else {
                return pdp(de, e);
            }
        }
    }        
    double len() {
        return (e - s).len();
    }
} l[205];
struct State {
    Point p; int f;
    bool operator < (const State &s) const {
        return p < s.p;
    }
};
struct Pol {
    int n; Point p[35]; Line l[35];
    Point gpoint() {
        double S = 0; Point res = Point(0, 0);
        for (int i = 1; i <= n; ++i) {
            double s = p[i] ^ p[i % n + 1];
            res = res + (p[i] + p[i % n + 1]) / 3 * s;
            S += s;
        }
        return res / S;
    }
    bool hasp(Point p) {
        Line key = Line(p, p + Point(INF, 0));
        int f = 0;
        for (int i = 1; i <= n; ++i) {
            if (!sgn(l[i].e.y - l[i].s.y)) continue;
            int f1 = sgn(l[i].s.y - p.y);
            int f2 = sgn(l[i].e.y - p.y);
            if (f1 == f2) continue;
            Point tp = key & l[i];
            if (sgn(tp.x - p.x) == -1) continue;
            f += (f1 < f2 ? -1 : 1) * (!!f1 + !!f2);
        }
        return f;
    }
    pdp dis(Point p) {
        if (hasp(p)) return pdp(0, p);
        pdp res = pdp(1e18, Point(0, 0));
        for (int i = 1; i <= n; ++i) {
            pdp tt = l[i].dis(p);
            res = min(res, tt);
        }
        return res;
    }
    void input() {
        scanf("%d", &n);
        for (int i = 1; i <= n; ++i) {
            p[i].input();
        }
        for (int i = 1; i <= n; ++i) {
            l[i] = Line(p[i], p[i % n + 1]);
        }
    }
} pol[22];
int c, n;
double ans;
void solve() {
    queue<Line> que;
    for (int i = 1; i < n; ++i) {
        que.push(l[i]);
    }
    while (que.size()) {
        Line l = que.front(); que.pop();
        Point s = l.s, e = l.e;
        if ((s - e).len() < 1e-3) continue;
        double ds = INF, de = INF;
        Point a, b;
        for (int i = 1; i <= c; ++i) {
            pdp td = pol[i].dis(s);
            if (td.first < ds) {
                ds = td.first;
                a = td.second;
            }
            td = pol[i].dis(e);
            if (td.first < de) {
                de = td.first;
                b = td.second;
            }
        }
        ans = max(ans, max(ds, de));
        double sta = 0, en = 1, mi;
        Point tp;
        while (sta <= en - EPS) {
            mi = (sta + en) * 0.5;
            tp = s * mi + e * (1 - mi);
            double d1 = (tp - a).len(), d2 = (tp - b).len();
            if (d1 < d2) {
                en = mi;
            } else {
                sta = mi;
            }
        }
        if ((tp - a).len() < ans) continue;
        que.push(Line(s, tp));
        que.push(Line(e, tp));
    }
}
int main() {
    scanf("%d%d", &c, &n);
    for (int i = 1; i <= n; ++i) {
        p[i].input();
    }
    for (int i = 1; i < n; ++i) {
        l[i] = Line(p[i], p[i + 1]);
    }
    for (int i = 1; i <= c; ++i) {
        pol[i].input();
    }        
    solve();
    printf("%.2f
", ans);
    return 0;
}