【HDOJ】1542 Atlantis

离散化+线段树+扫描线，求覆盖面积。

 /* 1542 */
 #include <iostream>
 #include <string>
 #include <map>
 #include <queue>
 #include <set>
 #include <stack>
 #include <vector>
 #include <deque>
 #include <algorithm>
 #include <cstdio>
 #include <cmath>
 #include <ctime>
 #include <cstring>
 #include <climits>
 #include <cctype>
 #include <cassert>
 #include <functional>
 #include <iterator>
 #include <iomanip>
 using namespace std;
 //#pragma comment(linker,"/STACK:102400000,1024000")
 
 #define sti                set<int>
 #define stpii            set<pair<int, int> >
 #define mpii            map<int,int>
 #define vi                vector<int>
 #define pii                pair<int,int>
 #define vpii            vector<pair<int,int> >
 #define rep(i, a, n)     for (int i=a;i<n;++i)
 #define per(i, a, n)     for (int i=n-1;i>=a;--i)
 #define clr                clear
 #define pb                 push_back
 #define mp                 make_pair
 #define fir                first
 #define sec                second
 #define all(x)             (x).begin(),(x).end()
 #define SZ(x)             ((int)(x).size())
 #define lson            l, mid, rt<<1
 #define rson            mid+1, r, rt<<1|1
 
 typedef struct segment_t {
     double l, r, h;
     int f;
 
     friend bool operator< (const segment_t& a, const segment_t& b) {
         return a.h < b.h;
     }
 
 } segment_t;
 
 typedef struct {
     int l, r, c;
     double len;
 } node_t;
 
 const int maxn = ;
 double X[maxn];
 segment_t seg[maxn];
 node_t nd[maxn<<];
 
 void build(int l, int r, int rt) {
     nd[rt].l = l;
     nd[rt].r = r;
     nd[rt].c = ;
     nd[rt].len = ;
 
     if (l == r)
         return ;
 
     int mid = (l + r) >> ;
     build(lson);
     build(rson);
 }
 
 void PushUp(int rt) {
     if (nd[rt].c)
         nd[rt].len = X[nd[rt].r+] - X[nd[rt].l];
     else if (nd[rt].r == nd[rt].l)
         nd[rt].len = ;
     else
         nd[rt].len = nd[rt<<].len + nd[rt<<|].len;
 }
 
 void update(int L, int R, int delta, int rt) {
     if (L<=nd[rt].l && nd[rt].r<=R) {
         nd[rt].c += delta;
         PushUp(rt);
         return ;
     }
 
     int mid = (nd[rt].l + nd[rt].r) >> ;
 
     if (mid >= R) {
         update(L, R, delta, rt<<);
     } else if (mid < L) {
         update(L, R, delta, rt<<|);
     } else {
         update(L, R, delta, rt<<);
         update(L, R, delta, rt<<|);
     }
 
     PushUp(rt);
 }
 
 int main() {
     ios::sync_with_stdio(false);
     #ifndef ONLINE_JUDGE
         freopen("data.in", "r", stdin);
         freopen("data.out", "w", stdout);
     #endif
 
     int n, m, xn;
     double x1, x2, y1, y2;
     double ans;
     int L, R;
     int tt = ;
 
     while (scanf("%d",&n)!=EOF && n) {
         ans = .;
         m = ;
         rep(i, , n) {
             scanf("%lf %lf %lf %lf", &x1,&y1,&x2,&y2);
             seg[m].l = seg[m+].l = x1;
             seg[m].r = seg[m+].r = x2;
             seg[m].h = y1;
             seg[m].f = ;
             seg[m+].h = y2;
             seg[m+].f = -;
 
             X[m] = x1;
             X[m+] = x2;
 
             m += ;
         }
 
         sort(seg, seg+m);
         sort(X, X+m);
         xn = unique(X, X+m)-X;
 
         build(, xn-, );
 
         rep(i, , m) {
             L = lower_bound(X, X+xn, seg[i].l) - X;
             R = lower_bound(X, X+xn, seg[i].r) - X - ;
             update(L, R, seg[i].f, );
             ans += (seg[i+].h - seg[i].h) * nd[].len;
             #ifndef ONLINE_JUDGE
                 printf("L = %d, R = %d, len = %.2lf\n", L, R, nd[].len);
             #endif
         }
 
         printf("Test case #%d\n", ++tt);
         printf("Total explored area: %.02lf\n\n", ans);
     }
 
     #ifndef ONLINE_JUDGE
         printf("time = %d.\n", (int)clock());
     #endif
 
     return ;
 }