poj 3277 City Horizon (线段树 扫描线 矩形面积并)

题目链接

题意： 给一些矩形，给出长和高，其中长是用区间的形式给出的，有些区间有重叠，最后求所有矩形的面积。

分析： 给的区间的范围很大，所以需要离散化，还需要把y坐标去重，不过我试了一下不去重 也不会出错，

所有的区间都能列出来，只是在查找的时候费点事。

给的矩形相当于在同一水平线上的，也就是y1坐标相当于为0，其他的就和 poj 1151 Atlantis 差不多了。

我写的思路是按照矩形面积并的思路写的：

但是还有另一种方法也是挺简单的，就是把给的矩形按照高从小到大排序，然后依次插入线段树，后面插入的

高会覆盖前面矮的，也就是覆盖了矩形的高，查找的时候按照00 11 22这种区间查找，只有找到h!=0的就是

当前的高，因为这表示这是后来插入的，也就是高的，然后乘上x的范围就是面积了。

 #include <iostream>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <cstdlib>
 #include <algorithm>
 #define LL __int64
 #define lson l, mid, 2*rt
 #define rson mid+1, r, 2*rt+1
 const int maxn = +;
 using namespace std;
 int n;
 double y[maxn];
 struct node
 {
     int l, r, c;
     int cnt, lf, rf;
 }tr[*maxn];
 struct Line
 {
     int x, y1, y2;
     int f;
 }line[maxn];
 bool cmp(Line a, Line b)
 {
     return a.x < b.x;
 }
 void build(int l, int r, int rt)
 {
     tr[rt].l = l; tr[rt].r = r;
     tr[rt].cnt = tr[rt].c = ;
     tr[rt].lf = y[l]; tr[rt].rf = y[r];
     if(l+==r) return;
     int mid = (l+r)/;
     build(l, mid, *rt);
     build(mid, r, *rt+);
 }
 void calen(int rt)
 {
     if(tr[rt].c>)
     {
         tr[rt].cnt = tr[rt].rf-tr[rt].lf;
         return;
     }
     if(tr[rt].l+==tr[rt].r) tr[rt].cnt = ;
     else tr[rt].cnt = tr[*rt].cnt+tr[*rt+].cnt;
 }
 void update(int rt, Line e)
 {
     if(e.y1==tr[rt].lf && e.y2==tr[rt].rf)
     {
         tr[rt].c += e.f;
         calen(rt);
         return;
     }
     if(e.y2<=tr[*rt].rf) update(*rt, e);
     else if(e.y1>=tr[*rt+].lf) update(*rt+, e);
     else
     {
         Line tmp = e;
         tmp.y2 = tr[*rt].rf;
         update(*rt, tmp);
         tmp = e;
         tmp.y1 = tr[*rt+].lf;
         update(*rt+, tmp);
     }
     calen(rt);
  }
 int main()
 {
     int i, cnt;
     LL ans;
     int a, b, h;
     while(~scanf("%d", &n))
     {
         cnt = ; ans = ;
         for(i = ; i < n; i++)
         {
             scanf("%d%d%d", &a, &b, &h);
             line[cnt].x = a; line[cnt].y1 = ;
             line[cnt].y2 = h; line[cnt].f = ;
             y[cnt++] = ;
             line[cnt].x = b; line[cnt].y1 = ;
             line[cnt].y2 = h; line[cnt].f = -;
             y[cnt++] = h;

         }
         sort(line+, line+cnt, cmp);
         sort(y+, y+cnt);
         int m = unique(y+, y+cnt)-(y+);  //对y坐标去重，不去重也没错
         build(, m, );

         update(, line[]);
         for(i = ; i < cnt; i++)
         {
             ans += (LL)tr[].cnt*(line[i].x-line[i-].x);
             update(, line[i]);
         }
         printf("%I64d\n", ans);
     }
     return ;
 }