Picture【HDU - 1828】【扫描线】

题目链接

这道题求的是这些可能存在重叠的小方块可能构成的合成方块的周长的值是多少，有简单却会很复杂的做法就是去跑纵向和横向两次的扫描线，求得最后的两个周长和，但是这样的做法未免显得复杂了，我们完全可以只跑一次线段树（扫描线）来做到这样的要求。

思路：问题就是我们得去知道有多少个可以竖起来的边，也就是有在两条扫描线之间，有多少个独立的方块在其中？我们求得独立方块数，最后乘以2就是最后的竖的边的数量，那么在解决竖直边上的这个问题我们就首先解决了。接下去就是求解横向的边的长度，我们每次的扫描线，也就代表着目前处理到的线上有多长的区间，那么我们求一个与上一个状态的差值，就是目前没被覆盖的边的增加出来的周长了。于是，我们加起来就会得到最后的总的周长了。

 #include <iostream>
 #include <cstdio>
 #include <cmath>
 #include <string>
 #include <cstring>
 #include <algorithm>
 #include <limits>
 #include <vector>
 #include <stack>
 #include <queue>
 #include <set>
 #include <map>
 #define lowbit(x) ( x&(-x) )
 #define pi 3.141592653589793
 #define e 2.718281828459045
 #define INF 0x3f3f3f3f
 #define HalF (l + r)>>1
 #define lsn rt<<1
 #define rsn rt<<1|1
 #define Lson lsn, l, mid
 #define Rson rsn, mid+1, r
 #define QL Lson, ql, qr
 #define QR Rson, ql, qr
 #define myself rt, l, r
 using namespace std;
 typedef unsigned long long ull;
 typedef long long ll;
 const int maxN = 1e4 + ;
 int N, tot, X[maxN], _UP;
 struct node
 {
     int lx, rx, y, val;
     node(int a=, int b=, int c=, int d=):lx(a), rx(b), y(c), val(d) {}
 }line[maxN];
 bool cmp(node e1, node e2) { return e1.y < e2.y; }
 struct tree
 {
     int sum, siz, num;
     bool lc, rc;
     tree(int a=, int b=, int f=, bool c=false, bool d=false):sum(a), siz(b), num(f), lc(c), rc(d) {}
     void clear() { sum = siz = num = ; lc = rc = false; }
 }t[maxN<<];
 inline void buildTree(int rt, int l, int r)
 {
     t[rt].clear();
     if(l == r) return;
     int mid = HalF;
     buildTree(Lson);
     buildTree(Rson);
 }
 inline void pushup(int rt, int l, int r)
 {
     if(t[rt].siz)
     {
         t[rt].sum = X[r + ] - X[l];
         t[rt].lc = t[rt].rc = true;
         t[rt].num = ;
     }
     else if(l == r)
     {
         t[rt].sum = t[rt].num = ;
         t[rt].lc = t[rt].rc = false;
     }
     else
     {
         t[rt].sum = t[lsn].sum + t[rsn].sum;
         t[rt].lc = t[lsn].lc;   t[rt].rc = t[rsn].rc;
         t[rt].num = t[lsn].num + t[rsn].num - (t[lsn].rc && t[rsn].lc);
     }
 }
 inline void update(int rt, int l, int r, int ql, int qr, int val)
 {
     if(ql <= l && qr >= r)
     {
         t[rt].siz += val;
         pushup(myself);
         return;
     }
     int mid = HalF;
     if(qr <= mid) update(QL, val);
     else if(ql > mid) update(QR, val);
     else { update(QL, val); update(QR, val); }
     pushup(myself);
 }
 inline void init()
 {
     tot = ;
 }
 int main()
 {
     while(scanf("%d", &N) != EOF)
     {
         init();
         int lx, ly, rx, ry;
         for(int i=; i<=N; i++)
         {
             scanf("%d%d%d%d", &lx, &ly, &rx, &ry);
             line[++tot] = node(lx, rx, ly, );
             X[tot] = lx;
             line[++tot] = node(lx, rx, ry, -);
             X[tot] = rx;
         }
         sort(X + , X + tot + );
         sort(line + , line + tot + , cmp);
         _UP = (int)(unique(X + , X + tot + ) - X - );
         buildTree(, , _UP);
         int ans = , las = ;
         for(int i=, l, r; i<tot; i++)
         {
             l = (int)(lower_bound(X + , X + _UP + , line[i].lx) - X);
             r = (int)(lower_bound(X + , X + _UP + , line[i].rx) - X - );
             update(, , _UP, l, r, line[i].val);
             ans += abs(las - t[].sum);
             las = t[].sum;
             ans += (line[i + ].y - line[i].y) * (t[].num << );
         }
         ans += line[tot].rx - line[tot].lx;
         printf("%d\n", ans);
     }
     return ;
 }
 /*
 7
 -15 0 5 10
 -5 8 20 25
 15 -4 24 14
 0 -6 16 4
 2 15 10 22
 30 10 36 20
 34 0 40 16
 ans = 228
 */