poj 1066 Treasure Hunt (Geometry + BFS)

1066 -- Treasure Hunt

　　题意是，在一个金字塔中有一个宝藏，金字塔里面有很多的墙，要穿过墙壁才能进入到宝藏所在的地方。可是因为某些原因，只能在两个墙壁的交点连线的中点穿过墙壁。问最少要穿过多少墙壁才能得到宝藏。

　　比较容易想到的一个办法就是直接用中点构图，然后判断点与点之间是否能够直接相连，最后bfs得到最小距离。

　　我的代码也是这样做，结果相当险的900+ms通过。

代码如下：

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

using namespace std;

const double EPS = 1e-8;
const int N = 55;
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(y - a.y) == 0;}
    Point operator + (Point a) { return Point(x + a.x, y + a.y);}
    Point operator - (Point a) { return Point(x - a.x, y - a.y);}
    Point operator * (double p) { return Point(x * p, y * p);}
    Point operator / (double p) { return Point(x / p, y / p);}
} ;
inline double cross(Point a, Point b) { return a.x * b.y - a.y * b.x;}
inline double dot(Point a, Point b) { return a.x * b.x + a.y * b.y;}
inline double veclen(Point a) { return sqrt(dot(a, a));}
inline Point vecunit(Point x) { return x / veclen(x);}
inline Point normal(Point x) { return Point(-x.y, x.x) / veclen(x);}
inline bool onseg(Point x, Point a, Point b) { return sgn(cross(a - x, b - x)) == 0 && sgn(dot(a - x, b - x)) <= 0;}

struct Line {
    Point s, t;
    Line() {}
    Line(Point s, Point t) : s(s), t(t) {}
    Point vec() { return t - s;}
    Point point(double p) { return s + vec() * p;}
} ;
inline bool onseg(Point x, Line l) { return onseg(x, l.s, l.t);}
inline Point llint(Line a, Line b) { return a.point(cross(b.vec(), a.s - b.s) / cross(a.vec(), b.vec()));}

Point ips[N][N], trs, vex[N * N];
bool out[N * N];
int ipcnt[N], vexcnt;
Line ls[N];

void input(int &n) {
    Point tmp[2];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 2; j++) cin >> tmp[j].x >> tmp[j].y;
        ls[i] = Line(tmp[0], tmp[1]);
    }
    ls[n++] = Line(Point(0.0, 0.0), Point(100.0, 0.0));
    ls[n++] = Line(Point(100.0, 0.0), Point(100.0, 100.0));
    ls[n++] = Line(Point(100.0, 100.0), Point(0.0, 100.0));
    ls[n++] = Line(Point(0.0, 100.0), Point(0.0, 0.0));
    cin >> trs.x >> trs.y;
}

inline Point mid(Point a, Point b) { return (a + b) / 2.0;}

int makevex(int n) {
    Point tmp;
    memset(ipcnt, 0, sizeof(ipcnt));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (sgn(cross(ls[i].vec(), ls[j].vec()))) {
                tmp = llint(ls[i], ls[j]);
                if (onseg(tmp, ls[i])) ips[i][ipcnt[i]++] = tmp;
                if (onseg(tmp, ls[j])) ips[j][ipcnt[j]++] = tmp;
            }
        }
    }
    vexcnt = 0;
    vex[vexcnt++] = trs;
    memset(out, 0, sizeof(out));
    for (int i = 0; i < n; i++) {
        ips[i][ipcnt[i]++] = ls[i].s;
        ips[i][ipcnt[i]++] = ls[i].t;
        sort(ips[i], ips[i] + ipcnt[i]);
        for (int j = 1; j < ipcnt[i]; j++) {
            if (ips[i][j - 1] == ips[i][j]) continue;
            vex[vexcnt++] = mid(ips[i][j - 1], ips[i][j]);
        }
    }
//    cout << vexcnt << endl;
    for (int i = 0; i < vexcnt; i++) {
        for (int j = n - 4; j < n; j++) {
            if (onseg(vex[i], ls[j])) {
                out[i] = true;
                break;
            }
        }
    }
//    for (int i = 0; i < vexcnt; i++) cout << out[i]; cout << endl;
    return vexcnt;
}

inline bool ssint(Line a, Line b) { return sgn(cross(a.s - b.s, a.t - b.s)) * sgn(cross(a.s - b.t, a.t - b.t)) < 0
                                        && sgn(cross(b.s - a.s, b.t - a.s)) * sgn(cross(b.s - a.t, b.t - a.t)) < 0;}

bool mat[N * N][N * N];

bool test(int i, int j, int n) {
    Line tmp = Line(vex[i], vex[j]);
    for (int a = 0; a < n; a++)
        if (onseg(vex[i], ls[a]) && onseg(vex[j], ls[a])) return false;
    for (int a = 0; a < n; a++)
        if (ssint(tmp, ls[a])) return false;
    return true;
}

void makemat(int n, int m) {
    memset(mat, 0, sizeof(mat));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (test(i, j, m)) mat[i][j] = mat[j][i] = true;
        }
    }
//    for (int i = 0; i < n; i++) {
//        for (int j = 0; j < n; j++) cout << mat[i][j]; cout << endl;
//    }
}

int q[N * N * N];
bool vis[N * N];

int bfs(int n) {
    int qh, qt;
    memset(vis, 0, sizeof(vis));
    qh = qt = 0;
    q[qt++] = 0;
    vis[0] = true;
    int cnt = 0;
    while (qh < qt) {
        int sz = qt - qh;
        cnt++;
        for (int i = 0; i < sz; i++) {
            int cur = q[qh++];
//            cout << cur << endl;
//            cout << vex[cur].x << ' ' << vex[cur].y << endl;
            for (int j = 0; j < n; j++) {
                if (vis[j] || !mat[cur][j]) continue;
                q[qt++] = j;
                vis[j] = true;
                if (out[j]) return cnt;
            }
        }
    }
    return -1;
}

int main() {
//    freopen("in", "r", stdin);
    int n;
    while (cin >> n) {
        input(n);
        int m;
        makemat(m = makevex(n), n);
        cout << "Number of doors = " << bfs(m) << endl;
    }
    return 0;
}

——written by Lyon