hdu3265 Posters（切割+面积并）

http://acm.hdu.edu.cn/showproblem.php?pid=3265

题意：给你n张海报，都是带洞的，求整体面积并。

思路：把一个带洞矩形纵向切割成四个小矩形，每输入一组数据插入4个矩形，然后就是普通的面积并。记得两个结构体和离散数组都开八十万，就是因为离散数组开了十万WA了好几次。还有这题不能用c++提交。。

#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <iostream>

using namespace std;

typedef long long LL;

const int N = 100010;
const int INF = 1e8;

struct line
{
    __int64 l, r;
    __int64 cnt;
    __int64 len;
}tree[8*N];

struct node
{
    __int64 l, r, h;
    __int64 f;
    bool operator < (const struct node & tmp) const
    {
        return h < tmp.h;
    }
}seg[8*N];

__int64 x[N*8];

void build(__int64 i, __int64 l, __int64 r)
{
    tree[i].l = l;
    tree[i].r = r;
    tree[i].len = 0;
    tree[i].cnt = 0;
    if(l == r)
    {
        return;
    }
    __int64 mid = (l+r) >> 1;
    build(i*2, l, mid);
    build(i*2+1, mid+1, r);
}

__int64 binsearch(__int64 key, __int64 k)
{
    __int64 high = k;
    __int64 low = 1;
    while(high >= low)
    {
        __int64 mid = (high+low) >> 1;
        if(x[mid] == key)
        {
            return mid;
        }
        else if(x[mid] < key)
        {
            low = mid+1;
        }
        else high = mid-1;
    }
    return -1;
}

void getlen(__int64 i)
{
    if(tree[i].cnt)
    {
        tree[i].len = x[tree[i].r+1]-x[tree[i].l];
        return;
    }
    if(tree[i].l == tree[i].r)
    {
        tree[i].len = 0;
        return;
    }
    tree[i].len = tree[i*2].len+tree[i*2+1].len;
}


void update(__int64 i, __int64 l, __int64 r, __int64 f)
{
    if(r < l) return;
    if(tree[i].l == l && tree[i].r == r)
    {
        tree[i].cnt += f;
        getlen(i);
        return;
    }
    __int64 mid = (tree[i].l+tree[i].r) >> 1;
    if(mid >= r)
        update(i*2, l, r, f);
    else if(mid < l)
        update(i*2+1, l, r, f);
    else
    {
        update(i*2, l, mid, f);
        update(i*2+1, mid+1, r, f);
    }
    getlen(i);
}

int main()
{
    freopen("in.txt", "r", stdin);
    __int64 n, x1, y1, x2, y2, x3, y3, x4, y4;
    while(~scanf("%I64d", &n))
    {
        if(n == 0) break;
        __int64 num = 1;
        for(__int64 i = 1; i <= n; i++)
        {
            scanf("%I64d%I64d%I64d%I64d%I64d%I64d%I64d%I64d", &x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);
            //第一个矩形
            seg[num] = (struct node){x1, x3, y1, 1};
            x[num++] = x1;

            seg[num] = (struct node){x1, x3, y2, -1};
            x[num++] = x3;
            //第二个矩形
            seg[num] = (struct node){x3, x4, y1, 1};
            x[num++] = x3;

            seg[num] = (struct node){x3, x4, y3, -1};
            x[num++] = x4;
            //第三个矩形
            seg[num] = (struct node){x3, x4, y4, 1};
            x[num++] = x3;

            seg[num] = (struct node){x3, x4, y2, -1};
            x[num++] = x4;
            //第四个矩形
            seg[num] = (struct node){x4, x2, y1, 1};
            x[num++] = x4;

            seg[num] = (struct node){x4, x2, y2, -1};
            x[num++] = x2;
        }
        sort(seg+1, seg+num);
        sort(x+1, x+num);
        __int64 k = 1;
        for(__int64 i = 2; i < num; i++)
        {
            if(x[i-1] != x[i])
            {
                x[++k] = x[i];
            }
        }
        build(1, 1, k);
        __int64 ans = 0;
        for(__int64 i = 1; i < num; i++)
        {
            __int64 l = binsearch(seg[i].l, k);
            __int64 r = binsearch(seg[i].r, k)-1;
            update(1, l, r, seg[i].f);
            ans += (seg[i+1].h-seg[i].h)*tree[1].len;
        }
        printf("%I64d\n", ans);
    }
    return 0;
}