hdu 4629 Burning （扫描线）

Problem - 4629

　　以前写过PSLG模拟的版本，今天写了一下扫描线做这题。

　　其实这题可以用set存线段来做，类似于判断直线交的做法。不过实现起来有点麻烦，于是我就直接暴力求交点了。

代码如下：

 #include <set>
 #include <queue>
 #include <cmath>
 #include <cstdio>
 #include <cstring>
 #include <iomanip>
 #include <iostream>
 #include <algorithm>

 using namespace std;

 const double EPS = 1e-;
 inline int sgn(double x) { return (x > EPS) - (x < -EPS);}
 typedef pair<double, double> Point;
 #define x first
 #define y second
 Point operator + (Point a, Point b) { return Point(a.x + b.x, a.y + b.y);}
 Point operator - (Point a, Point b) { return Point(a.x - b.x, a.y - b.y);}
 Point operator * (Point a, double p) { return Point(a.x * p, a.y * p);}
 Point operator / (Point a, double p) { return Point(a.x / p, a.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 rotate(Point a) {
     double cosx = cos(0.001), sinx = sin(0.001);
     return Point(a.x * cosx - a.y * sinx, a.x * sinx + a.y * cosx);
 }

 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 Point llint(Line a, Line b) { return a.point(cross(b.vec(), a.s - b.s) / cross(a.vec(), b.vec()));}
 void scan(Point &a) { cin >> a.x >> a.y;}
 const int N = ;
 Point tri[N][];

 bool check(int n) {
     for (int i = ; i < n; i++) {
         for (int j = ; j < ; j++) {
             if (sgn(tri[i][j].x - tri[i][j + ].x) == ) return ;
         }
     }
     return ;
 }
 void adjust(int n) { for (int i = ; i < n; i++) for (int j = ; j < ; j++) tri[i][j] = rotate(tri[i][j]);}
 inline bool between(Point p, Point a, Point b) { return sgn(dot(a - p, b - p)) <= ;}
 bool cmpy(Point a, Point b) { return a.y < b.y;}

 bool triline(Line l, int id, Point *ip) {
     Point tmp[];
     int tt = ;
     for (int i = ; i < ; i++) {
         tmp[tt] = llint(l, Line(tri[id][i], tri[id][i + ]));
         if (between(tmp[tt], tri[id][i], tri[id][i + ])) tt++;
     }
     sort(tmp, tmp + tt, cmpy);
     ip[] = tmp[], ip[] = tmp[tt - ];
     return tt > ;
 }

 typedef pair<double, int> Break;
 bool cmp(Break a, Break b) { return sgn(a.x - b.x) <  || sgn(a.x - b.x) ==  && a.y < b.y;}
 Break ips_l[N << ], ips_r[N << ];
 double area[N], len_l[N], len_r[N], event[N * N << ];
 void scanline(int n) {
     memset(area, , sizeof(area));
     int tt = ;
     for (int i = ; i < n; i++) {
         for (int j = ; j < ; j++) {
             Point a = tri[i][j], b = tri[i][j + ];
             event[tt++] = a.x;
             for (int k = ; k < n; k++) {
                 for (int l = ; l < ; l++) {
                     Point c = tri[k][l], d = tri[k][l + ];
                     if (sgn(cross(b - a, d - c)) == ) continue;
                     Point ip = llint(Line(a, b), Line(c, d));
                     //cout << ip.x << ' ' << ip.y << endl;
                     if (between(ip, a, b) && between(ip, c, d)) {
                         event[tt++] = ip.x;
                     }
                 }
             }
         }
     }
     sort(event, event + tt);
     tt = (int) (unique(event, event + tt) - event);
     Line cur;
     Point tmp[];
     for (int i = , c, cnt; i < tt; i++) {
         if (sgn(event[i - ] - event[i]) == ) continue;
         c = ;
         cur = Line(Point(event[i - ] + EPS, 0.0), Point(event[i - ] + EPS, 1.0));
         for (int j = ; j < n; j++) {
             if (triline(cur, j, tmp)) {
                 ips_l[c++] = Break(tmp[].y, ), ips_l[c++] = Break(tmp[].y, -);
             }
         }
         sort(ips_l, ips_l + c, cmp);
         cnt = ;
         memset(len_l, , sizeof(len_l));
         for (int j = ; j < c; j++) {
             if (cnt > ) len_l[cnt] += ips_l[j].x - ips_l[j - ].x;
             cnt += ips_l[j].y;
         }
         c = ;
         cur = Line(Point(event[i] - EPS, 0.0), Point(event[i] - EPS, 1.0));
         for (int j = ; j < n; j++) {
             if (triline(cur, j, tmp)) {
                 ips_r[c++] = Break(tmp[].y, ), ips_r[c++] = Break(tmp[].y, -);
             }
         }
         sort(ips_r, ips_r + c, cmp);
         cnt = ;
         memset(len_r, , sizeof(len_r));
         for (int j = ; j < c; j++) {
             if (cnt > ) len_r[cnt] += ips_r[j].x - ips_r[j - ].x;
             cnt += ips_r[j].y;
         }
         for (int j = ; j <= n; j++) area[j] += (len_l[j] + len_r[j]) * (event[i] - event[i - ]) / ;
     }
 }

 int main() {
     ios::sync_with_stdio();
     cout << setiosflags(ios::fixed) << setprecision();
     int T, n;
     cin >> T;
     while (T-- && cin >> n) {
         int tt = ;
         for (int i = ; i < n; i++) {
             for (int j = ; j < ; j++) scan(tri[tt][j]);
             tri[tt][] = tri[tt][];
             if (sgn(cross(tri[tt][] - tri[tt][], tri[tt][] - tri[tt][]))) tt++;
         }
         while (check(tt)) adjust(tt);
         scanline(tt);
         for (int i = ; i <= n; i++) area[i] = fabs(area[i]);
         for (int i = ; i <= n; i++) cout << area[i] << endl;
     }
     return ;
 }

——written by Lyon