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-;
 const int N = ;
 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) <  || sgn(x - a.x) ==  && y < a.y;}
     bool operator == (Point a) const { return sgn(x - a.x) ==  && sgn(y - a.y) == ;}
     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)) ==  && sgn(dot(a - x, b - x)) <= ;}
 
 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[];
     for (int i = ; i < n; i++) {
         for (int j = ; j < ; j++) cin >> tmp[j].x >> tmp[j].y;
         ls[i] = Line(tmp[], tmp[]);
     }
     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, , sizeof(ipcnt));
     for (int i = ; i < n; i++) {
         for (int j = ; 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 = ;
     vex[vexcnt++] = trs;
     memset(out, , sizeof(out));
     for (int i = ; 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 = ; j < ipcnt[i]; j++) {
             if (ips[i][j - ] == ips[i][j]) continue;
             vex[vexcnt++] = mid(ips[i][j - ], ips[i][j]);
         }
     }
 //    cout << vexcnt << endl;
     for (int i = ; i < vexcnt; i++) {
         for (int j = n - ; 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)) <
                                         && sgn(cross(b.s - a.s, b.t - a.s)) * sgn(cross(b.s - a.t, b.t - a.t)) < ;}
 
 bool mat[N * N][N * N];
 
 bool test(int i, int j, int n) {
     Line tmp = Line(vex[i], vex[j]);
     for (int a = ; a < n; a++)
         if (onseg(vex[i], ls[a]) && onseg(vex[j], ls[a])) return false;
     for (int a = ; a < n; a++)
         if (ssint(tmp, ls[a])) return false;
     return true;
 }
 
 void makemat(int n, int m) {
     memset(mat, , sizeof(mat));
     for (int i = ; i < n; i++) {
         for (int j = ; 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, , sizeof(vis));
     qh = qt = ;
     q[qt++] = ;
     vis[] = true;
     int cnt = ;
     while (qh < qt) {
         int sz = qt - qh;
         cnt++;
         for (int i = ; i < sz; i++) {
             int cur = q[qh++];
 //            cout << cur << endl;
 //            cout << vex[cur].x << ' ' << vex[cur].y << endl;
             for (int j = ; j < n; j++) {
                 if (vis[j] || !mat[cur][j]) continue;
                 q[qt++] = j;
                 vis[j] = true;
                 if (out[j]) return cnt;
             }
         }
     }
     return -;
 }
 
 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 ;
 }

——written by Lyon