HDU - 1828 Picture

题目链接

题意 

多个矩形重叠在一起，求出轮廓线的长度。

分析 

把矩形分成横线和竖线来处理。现在分析横线的，竖线同理。矩形的坐标都是整数，且范围不大，故此题不需要离散化。从下往上扫描横线，每遇到一条横线，就计算长度，矩形的下边标为1，上边标为-1。具体计算方法是此次区间的总覆盖长度与上次区间长度相比，若没有变化，则说明新加入的横线是重叠的。故每次计算的答案便是两者之差的绝对值。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include <queue>
#include <vector>
#include<bitset>
#include<map>
#include<deque>
using namespace std;
typedef long long LL;
const int maxn = ;
const int mod = +;
typedef pair<int,int> pii;
#define X first
#define Y second
#define pb push_back
//#define mp make_pair
#define ms(a,b) memset(a,b,sizeof(a))
const int inf = 0x3f3f3f3f;
#define lson l,m,2*rt
#define rson m+1,r,2*rt+1

struct edge{
    int l,r,h,f;
}ex[*maxn],ey[maxn*];

struct node{
    int l,r,cover,len;
    int mid(){
        return (l+r)>>;
    }
}tree[maxn*];

int cmp(edge a,edge b){
    return a.h<b.h;
}

void build(int l,int r,int rt){
    tree[rt].l=l,tree[rt].r=r;
    tree[rt].len=tree[rt].cover=;
    if(l+==r) return;
    int mid = tree[rt].mid();
    build(l,mid,rt<<);
    build(mid,r,rt<<|);
}

void push_up(int rt){
    if(tree[rt].cover){
        tree[rt].len=tree[rt].r-tree[rt].l;
    }else if(tree[rt].l+==tree[rt].r){
        tree[rt].len=;
    }else{
        tree[rt].len=tree[rt<<].len+tree[rt<<|].len;
    }
    return;
}

void update(edge e,int rt){
    if(tree[rt].l==e.l&&tree[rt].r==e.r){
        tree[rt].cover+=e.f;
        push_up(rt);
        return;
    }
    int m=tree[rt].mid();
    if(e.r<=m) update(e,rt<<);
    else if(e.l>=m) update(e,rt<<|);
    else{
        edge temp = e;
        temp.r=m;
        update(temp,rt<<);
        temp = e;
        temp.l=m;
        update(temp,rt<<|);
    }
    push_up(rt);
}
int ans;
void work(int l,int r,edge seg[],int n){
    build(l,r,);
    int prelen=;
    for(int i=;i<n;i++){
        update(seg[i],);
        ans += abs(tree[].len-prelen);
        prelen=tree[].len;
    }
}

int main(){
    int n,x1,x2,y1,y2;
    while(~scanf("%d",&n)){
        if(n==){
            puts("");
            continue;
        }

        int maxx,maxy,minx,miny;
        maxx=maxy=-inf,minx=miny=inf;
        int cnt=;
        for(int i=;i<n;i++){
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            //横向
            ex[cnt].l=ex[cnt+].l=x1,
            ex[cnt].r=ex[cnt+].r=x2,
            ex[cnt].h=y1,ex[cnt+].h=y2,
            ex[cnt].f=,ex[cnt+].f=-;

            ey[cnt].l=ey[cnt+].l=y1,
            ey[cnt].r=ey[cnt+].r=y2,
            ey[cnt].h=x1,ey[cnt+].h=x2,
            ey[cnt].f=,ey[cnt+].f=-;
            cnt+=;

            maxx=max(maxx,max(x1,x2));
            minx=min(minx,min(x1,x2));
            miny=min(miny,min(y1,y2));
            maxy=max(maxy,max(y1,y2));
        }

        sort(ex,ex+cnt,cmp);
        sort(ey,ey+cnt,cmp);
        ans=;
        work(minx,maxx,ex,cnt);
        work(miny,maxy,ey,cnt);
        printf("%d\n",ans);
    }
    return ;
}

还有一种更好的做好，参见http://www.cnblogs.com/scau20110726/archive/2013/04/13/3018687.html

同时计算横线和竖线

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 5010
#define MAX 10100
#define lch(i) ((i)<<1)
#define rch(i) ((i)<<1|1)

struct segment{
    int l,r,h,v;
}s[*N];
struct node{
    int l,r,lp,rp,cnt,len,num;
    int mid()
    { return (l+r)>>; }
}t[*MAX*];

int cmp(struct segment p ,struct segment q)
{
    return p.h<q.h;
}

void build(int l ,int r, int rt)
{
    t[rt].l=l; t[rt].r=r;
    t[rt].cnt=t[rt].len=;
    t[rt].lp=t[rt].rp=t[rt].num=;
    if(l==r) return ;
    int mid=t[rt].mid();
    build(l,mid,lch(rt));
    build(mid+,r,rch(rt));
}

void cal(int rt)
{
    if(t[rt].cnt)
    {
        t[rt].len=t[rt].r-t[rt].l+;
        t[rt].lp=t[rt].rp=;
        t[rt].num=;
    }
    else if(t[rt].l == t[rt].r) //叶子
    {
        t[rt].len=;
        t[rt].lp=t[rt].rp=;
        t[rt].num=;
    }
    else
    {
        t[rt].len=t[lch(rt)].len+t[rch(rt)].len;
        t[rt].lp=t[lch(rt)].lp;
        t[rt].rp=t[rch(rt)].rp;
        t[rt].num=t[lch(rt)].num + t[rch(rt)].num - (t[lch(rt)].rp&t[rch(rt)].lp);
    }
}

void updata(int l ,int r ,int v ,int rt)
{
    if(t[rt].l==l && t[rt].r==r) //目标区间
    {
        t[rt].cnt += v;
        cal(rt);
        return ;
    }
    int mid=t[rt].mid();
    if(r<=mid)     updata(l,r,v,lch(rt));
    else if(l>mid) updata(l,r,v,rch(rt));
    else
    {
        updata(l,mid,v,lch(rt));
        updata(mid+,r,v,rch(rt));
    }
    cal(rt);
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==)
        { puts(""); continue; }
        int i,maxx,minx,m;
        for(i=,m=,maxx=-MAX,minx=MAX; i<n; i++,m+=)
        {
            int x1,y1,x2,y2;
            scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
            maxx=max(maxx,x2);
            minx=min(minx,x1);
            s[m].l=x1;   s[m].r=x2;   s[m].h=y1;   s[m].v=;
            s[m+].l=x1; s[m+].r=x2; s[m+].h=y2; s[m+].v=-;
        }
        sort(s,s+m,cmp);
        build(minx,maxx-,);
        int res= , prelen=;
        s[m]=s[m+]; //每次处理循环的最后一次
        for(int i=; i<m; i++)
        {
            updata(s[i].l,s[i].r-,s[i].v,);
            res += abs(t[].len-prelen); //计算横线部分
            res += (s[i+].h-s[i].h)*(*t[].num); //计算竖线部分
            prelen=t[].len;
        }
        printf("%d\n",res);
    }
    return ;
}