[线段树]picture

PICTURE

题目描述

N(N<5000) 张矩形的海报，照片和其他同样形状的图片贴在墙上。它们的边都是垂直的或水平的。每个矩形可以部分或者全部覆盖其他矩形。所有的矩形组成的集合的轮廓称为周长。写一个程序计算周长。

图 1 是一个有 7 个矩形的例子：

图 1.一个 7 个矩形的集合对应的轮廓为图 2 所示的所有线段的集合：

图 2. 矩形集合的轮廓

所有矩形的顶点坐标均为整数。所有的坐标都在 [-10000，10000] 的范围内，并且任何一个矩形面积都为整数。结果的值可能需要 32 位有符号整数表示。

输入

第1行: N，张贴在墙上的矩形的数目。 第 2..N+1行 接下来的N行中，每行都有两个点的坐标，分别是矩形的左下角坐标和右上角坐标。每一个坐标由 X 坐标和 Y 坐标组成。

输出

只有一行，为一个非负整数，表示输入数据中所有矩形集合的轮廓长度。

样例输入

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

样例输出

228

自己写(chao)的，并没有用线段树维护，加了快读8ms

 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 using namespace std; 

 struct data {
     int lx, rx;
     int ly, ry;
 }; 

 const int maxn = , maxx = ;
 int n;
 data a[maxn + ];
 int level[maxx + ]; 

 bool cmp_x(data x, data y) {
     return x.lx < y.lx;
 } 

 bool cmp_y(data x, data y) {
     return x.ly < y.ly;
 } 

 int in() {
     int f = , p = ;
     char c;
     while (c < '' || c > '') {
         c = getchar();
         if (c == '-') {
             f = -;
         }
     }
     while (c >= '' && c <= '') {
         p = p *  + c - '';
         c = getchar();
     }
     p *= f;
     return p;
 } 

 void init() {
     n = in();
     for (int i = ; i <= n; i++) {
         a[i].lx = in();
         a[i].ly = in();
         a[i].rx = in();
         a[i].ry = in();
         a[i].lx += ;
         a[i].ly += ;
         a[i].rx += ;
         a[i].ry += ;
     }
 } 

 int solve_x() {
     memset(level, -, sizeof(level));
     int ans = ;
     sort(a + , a +  + n, cmp_x);
     for (int i = ; i <= n; i++) {
         for (int j = a[i].ly; j < a[i].ry; j++) {
             if (level[j] < a[i].lx) {
                 ans += ;
             }
             if (level[j] < a[i].rx) {
                 level[j] = a[i].rx;
             }
         }
     }
     return ans;
 } 

 int solve_y() {
     memset(level, -, sizeof(level));
     int ans = ;
     sort(a + , a +  + n, cmp_y);
     for (int i = ; i <= n; i++) {
         for (int j = a[i].lx; j < a[i].rx; j++) {
             if (level[j] < a[i].ly) {
                 ans += ;
             }
             if (level[j] < a[i].ry) {
                 level[j] = a[i].ry;
             }
         }
     }
     return ans;
 } 

 int main() {
     init();
     printf("%d\n", solve_x() + solve_y());
     return ;
 } 

下面是学长的QAQQ用了线段树维护

 #include<cstdio>
 #include<algorithm>
 #define MN 10000
 #define MX 20000
 #define L (k << 1)
 #define R ((k << 1) + 1)
 using namespace std; 

 struct work{    //扫描线
     int x, l, r, p;
 }x[MN + ], y[MN + ];

 bool cmp(work a, work b){
     return a.x == b.x ? a.p > b.p : a.x < b.x;
 }

 struct data{
     int x, s;
 };

 data operator + (data a, data b){
     if (a.x == b.x) {
         return (data) {
             a.x, a.s + b.s
         };
     }
     return a.x < b.x ? a : b;
 }

 struct node{
     int l, r, mk;
     data x;
 }t[MX *  + ]; 

 inline void up (int k){
     t[k].x = t[L].x + t[R].x;
 }

 inline void add(int k, int x){
     t[k].x.x += x;
     t[k].mk += x;
 }

 inline void down(int k){
     if (t[k].mk) {
         add(L, t[k].mk);
         add(R, t[k].mk);
         t[k].mk = ;
     }
 }

 void build(int k, int l, int r) {
     t[k].l = l;
     t[k].r = r;
     if (l == r) {
         t[k].x.s = ;
         return;
     }
     int mid = l + r >> ;
     build(L, l, mid);
     build(R, mid + , r);
     up(k);
 }

 void renew(int k, int l, int r, int x) {
     if (t[k].l == l && t[k].r == r) {
         add(k, x);
         return;
     }
     down(k);
     int mid = t[k].l + t[k].r >> ;
     if (r <= mid) {
         renew(L, l, r, x);
     }
     else if (l > mid) {
         renew(R, l, r, x);
     }
     else {
         renew(L, l, mid, x);
         renew(R, mid + , r, x);
     }
     up(k);
 }

 data query(int k, int l, int r){
     if (t[k].l == l && t[k].r == r) {
         return t[k].x;
     }
     down(k);
     int mid = (t[k].l + t[k].r) >> ;
     if (r <= mid) {
         return query(L, l, r);
     }
     if (l > mid) {
         return query(R, l, r);
     }
     return query(L, l, mid) + query(R, mid + , r);
 }
 int n, ans;
 void solve (work *x) {
     for (int i = ; i < n; i++) {
         if (x[i].p < ) {
             renew(, x[i].l, x[i].r, -);
         }
         data d = query(, x[i].l, x[i].r);
         if (x[i].p > ) {
             renew(, x[i].l, x[i].r, );
         }
         ans += d.x ?  : d.s;
     }
 }

 int main(){
     int i, x0, y0, x1, y1;
     scanf("%d", &n);
     for (int i = ; i < n; ++i) {
         scanf("%d%d%d%d", &x0, &y0, &x1, &y1);
         x0 += MN;
         y0 += MN;
         x1 += MN;
         y1 += MN;
         x[i] = (work) {
             y0, x0, x1 - ,
         };
         x[i + n] = (work) {
             y1, x0, x1 - , -
         };
         y[i] = (work) {
             x0, y0, y1 - ,
         };
         y[i + n] = (work) {
             x1, y0, y1 - , -
         };
     }
     n <<= ;
     sort(x, x + n, cmp);
     sort(y, y + n, cmp);
     build(, , MX);
     solve(x);
     solve(y);
     printf("%d", ans);
     return ;
 }