【IOI 1998】 Picture

【题目链接】

点击打开链接

【算法】

线段树扫描线求周长并

【代码】

#include <algorithm>
#include <bitset>
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <limits>
#include <list>
#include <map>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
#include <cwchar>
#include <cwctype>
#include <stack>
#include <limits.h>
using namespace std;
#define MAXN 5010
 
 int i,L,R,l1,l2,ans,last,n,xa,xb,ya,yb;
 int x[MAXN*];
 
struct info {
        int l,r,h,opt;
} y[MAXN*];
struct Node {
        int l,r,sum,cnt,c;
        bool lc,rc;
} Tree[MAXN*];
 
bool cmp(info a,info b) { return a.h > b.h; }
template <typename T> inline void read(T &x) {
        int f = ; x = ;
        char c = getchar();
        for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }
        for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
        x *= f;
}
template <typename T> inline void write(T x) {
    if (x < ) { putchar('-'); x = -x; }
    if (x > ) write(x/);
    putchar(x%+'');
}
template <typename T> inline void writeln(T x)  {
    write(x);
    puts("");
}
inline void build(int index,int l,int r) {
        int mid;
        Tree[index].l = l;
        Tree[index].r = r;
        Tree[index].c = Tree[index].sum = Tree[index].cnt = ;
        Tree[index].lc = Tree[index].rc = false;
        if (l == r) return;
        mid = (l + r) >> ;
        build(index<<,l,mid);
        build(index<<|,mid+,r);
}
inline void push_up(int index) {
        if (Tree[index].c > ) {
                Tree[index].sum = x[Tree[index].r+] - x[Tree[index].l];
                Tree[index].cnt = ;
                Tree[index].lc = Tree[index].rc = true;
        } else if (Tree[index].l == Tree[index].r) {
                    Tree[index].sum = Tree[index].cnt = ;
                    Tree[index].lc = Tree[index].rc = false;
        } else {
                    Tree[index].lc = Tree[index<<].lc;
                    Tree[index].rc = Tree[index<<|].rc;
                    Tree[index].sum = Tree[index<<].sum + Tree[index<<|].sum;
                    Tree[index].cnt = Tree[index<<].cnt + Tree[index<<|].cnt;
                    if (Tree[index<<].rc && Tree[index<<|].lc) Tree[index].cnt--;
        }
}
inline void update(int index,int l,int r,int val) {
        int mid;
        if (Tree[index].l == l && Tree[index].r == r) {
                Tree[index].c += val;
                push_up(index);
                return;
        }
        mid = (Tree[index].l + Tree[index].r) >> ;
        if (mid >= r) update(index<<,l,r,val);
        else if (mid +  <= l) update(index<<|,l,r,val);
        else {
                update(index<<,l,mid,val);
                update(index<<|,mid+,r,val);
        }
        push_up(index);
}
 
int main() {
 
        scanf("%d",&n);
                l1 = l2 = ;
                for (i = ; i <= n; i++) {
                        read(xa); read(ya); read(xb); read(yb);
                        x[++l1] = xa;
                        x[++l1] = xb;
                        y[++l2] = (info){xa,xb,ya,-};
                        y[++l2] = (info){xa,xb,yb,};
                }
                l1 = unique(x+,x+l1+) - x;
                sort(x+,x+l1+);
                build(,,l1-);
                sort(y+,y+l2+,cmp);
                ans = last = ;
                for (i = ; i < l2; i++) {
                        L = lower_bound(x+,x+l1+,y[i].l) - x;
                        R = lower_bound(x+,x+l1+,y[i].r) - x - ;
                        update(,L,R,y[i].opt);
                        ans += Tree[].cnt *  * (y[i].h - y[i+].h);
                        ans += abs(Tree[].sum - last);
                        last = Tree[].sum;
                }
                L = lower_bound(x+,x+l1+,y[l2].l) - x;
                R = lower_bound(x+,x+l1+,y[l2].r) - x - ;
                update(,L,R,y[l2].opt);
                ans += abs(Tree[].sum - last);
                writeln(ans);
 
        return ;
 
}