|
|
題目鏈接：http://acm.hdu.edu.cn/showproblem.php?pid=3265
  /**//*
 題意：
給定N(N <= 50000)個中空的矩形紙片，求它們面積并。
解法：
離散化+線段樹
思路：
2010年寧波區域賽的題，就是矩形面積并的一個變形，轉化很容
易想到，將中空的矩形紙片分割成四個小的矩形然后求N*4個矩形的
面積并即可。
再總結一下矩形面積并的nlog(n)經典算法吧。首先我們將每個矩
形的縱向邊投影到Y軸上，這樣就可以把矩形的縱向邊看成一個閉區間
，用線段樹來維護這些矩形邊的并。現在求的是矩形的面積并，于是可
以枚舉矩形的x坐標，然后檢測當前相鄰x坐標上y方向的合法長度，兩
者相乘就是其中一塊面積，枚舉完畢后就求得了所有矩形的面積并。
我的線段樹結點描述保存了以下信息：區間的左右端點、結點所在
數組編號（因為采用靜態結點可以大大節省申請空間的時間）、該結點
被豎直線段完全覆蓋的次數Cover和當前結點的測度。測度是指相鄰x坐
標之間有效的y方向的長度的和（要求在該區間內）。于是重點就在于
如何維護測度，我們將一個矩形分成兩條豎直線段來存儲，左邊的邊稱
為入邊，右邊的邊則為出邊，然后把所有這些豎直線段按照x坐標遞增排
序，每次進行插入操作，因為坐標有可能不是整數，所以必須在做這些
之前將y方向的坐標離散化到數組中，每次插入時如果當前區間被完全覆
蓋，那么就要對Cover域進行更新，入邊+1，出邊-1。更新完畢后判斷當
前結點的Cover域是否大于零，如果大于零那么當前節點的測度就是結點
管理區間在y軸上的實際長度，否則，如果是葉子節點，那么測度為0，
如果是內部結點，那么測度的值是左右兒子測度的和。這個更新是log(n)
的，所以，總的復雜度就是nlog(n)。
 */
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef int Type;
#define ll __int64
#define maxn 200200
// 垂直線段
struct VLine  {
Type x;
Type y1, y2;
int val;
  VLine() {}
VLine(int _x, int _y1, int _y2, int _v) {
x = _x;
y1 = _y1;
y2 = _y2;
val = _v;
 }
};
vector <VLine> Vl;
bool cmp(VLine a, VLine b) {
return a.x < b.x;
}
// 矩形
struct Rectangle {
int x0, y0, x1, y1;
Rectangle() {}
Rectangle(int _x0, int _y0, int _x1, int _y1) {
x0 = _x0; y0 = _y0;
x1 = _x1; y1 = _y1;
}
};
vector <Rectangle> Rec;
int tmp[maxn], tmpsize;
int bin[maxn], size;
struct Tree {
int p;
int l, r;
int nCover; // 被完全覆蓋的次數
Type ylen; // 測度
void Update() {
if(nCover > 0)
ylen = bin[r] - bin[l];
else {
if(l + 1 == r)
ylen = 0;
else {
ylen = T[p<<1].ylen + T[p<<1|1].ylen;
}
}
}
int Mid() {
return (l + r) >> 1;
}
}T[maxn*4];
void Build(int p, int l, int r) {
T[p].l = l;
T[p].r = r;
T[p].p = p;
T[p].ylen = T[p].nCover = 0;
if(l + 1 == r || l == r)
return ;
int mid = (l + r) >> 1;
Build(p<<1, l, mid);
Build(p<<1|1, mid, r);
}
void Insert(int p, int l, int r, int val) {
if(l <= T[p].l && T[p].r <= r) {
T[p].nCover += val;
T[p].Update();
return ;
}
int mid = T[p].Mid();
if(l < mid) {
Insert(p<<1, l, r, val);
}
if(mid < r) {
Insert(p<<1|1, l, r, val);
}
T[p].Update();
}
void ProcessBinArray() {
sort(tmp, tmp + tmpsize);
bin[size = 1] = tmp[0];
int i;
for(i = 1; i < tmpsize; i++) {
if(tmp[i] != tmp[i-1])
bin[++size] = tmp[i];
}
}
int Binary(int v) {
int l = 1;
int r = size;
while(l <= r) {
int m = (l + r) >> 1;
if(bin[m] == v)
return m;
if(v > bin[m]) {
l = m + 1;
}else
r = m - 1;
}
}
int main() {
int n;
int i, j;
Type x[4], y[4];
while(scanf("%d", &n) != EOF && n) {
Rec.clear();
Vl.clear();
tmpsize = 0;
for(i = 0; i < n; i++) {
for(j = 0; j < 4; j++) {
scanf("%d %d", &x[j], &y[j]);
tmp[ tmpsize++ ] = y[j];
}
Rec.push_back(Rectangle(x[0], y[0], x[2], y[1]));
Rec.push_back(Rectangle(x[2], y[0], x[3], y[2]));
Rec.push_back(Rectangle(x[2], y[3], x[3], y[1]));
Rec.push_back(Rectangle(x[3], y[0], x[1], y[1]));
}
ProcessBinArray();
for(i = 0; i < Rec.size(); i++) {
Rectangle& rt = Rec[i];
if(rt.x0 == rt.x1 || rt.y0 == rt.y1)
continue;
int y0 = Binary(rt.y0);
int y1 = Binary(rt.y1);
Vl.push_back(VLine(rt.x0, y0, y1, 1));
Vl.push_back(VLine(rt.x1, y0, y1, -1));
}
sort(Vl.begin(), Vl.end(), cmp);
Build(1, 1, size);
ll ans = 0;
for(i = 0; i < Vl.size(); i++) {
if(i) {
ans += (ll)(Vl[i].x - Vl[i-1].x) * T[1].ylen;
}
Insert(1, Vl[i].y1, Vl[i].y2, Vl[i].val);
}
printf("%I64d\n", ans);
}
return 0;
}
|