USACO 5.5.1 Picture 离散化

http://train.usaco.org/usacoprob2?a=qNexyVCSx2z&S=picture

题目大意：给N个矩形（左下角和右上角坐标表示），求总覆盖图形的周长。（本题中坐标范围-10000到10000）

原本想用之前算覆盖面积的做法将矩形分裂成小矩形上浮，但是做的时候发现会出问题，因为在分裂的过程中面积的总和不变但是周长的总和会发生变化，可能出现某一段被覆盖的边长被多次处理的情况

看了题解发现用离散化暴力可行（线段树也可以，等我学了再试试看）

简单来说就是将每个矩形拆成四条线段处理，每个线段记录下（以水平线段为例）：位置（纵坐标）， 端点位置（两点横坐标），是否是矩形的底边（左侧边为1，右侧边为0）

由小到大排序（按位置比较大小，如果位置相同则底边较小）

遍历每一条边，对每一条边遍历其覆盖的单元格i（对水平线断而言是其在x轴上的投影），注意坐标点与单位边的间隔关系：

    如果是底边，先判断该位置对应的计数器sig[i]是否为零，为零则周长++，再sig[i]++

    如果是顶边，先sig[i]--，再判断sig[i]是否为零，为零则周长++

    因为底边顶边必定是一一匹配的，所以可以把它看作像一组组括号，要找到最外侧的括号，这样比较好理解

/*
ID: frontie1
TASK: picture
LANG: C++
*/
#include <iostream>
#include <cstdio>

using namespace std;

struct line
{
    int st, ed;
    int loc;
    int lower;

    bool operator<=(line &obj)
    {
        if(loc == obj.loc){
            return lower == 1 || obj.lower == 0;
        }
        else return loc < obj.loc;
    }
};

int N;
line horizontal[10010];
line vertical[10010];
int x1, y1, x2, y2;
int output = 0;
int sig1[20010];
int sig2[20020];

void quicksort(line arr[], int st, int ed)
{
    if(st >= ed) return;

    int lo = st, hi = ed;
    line tem = arr[st];
    while(lo < hi){
        while(lo < hi && tem <= arr[hi]) --hi;
        arr[lo] = arr[hi]; //++lo;
        while(lo < hi && arr[lo] <= tem) ++lo;
        arr[hi] = arr[lo]; //--hi;
    }
    arr[lo] = tem;
    quicksort(arr, st, lo-1);
    quicksort(arr, lo+1, ed);
}

int main()
{
    freopen("picture.in", "r", stdin);
    freopen("picture.out", "w", stdout);

    cin >> N;

    for(int i = 1; i <= N; ++i){
        cin >> x1 >> y1 >> x2 >> y2;

        x1 += 10000;
        x2 += 10000;
        y1 += 10000;
        y2 += 10000;

        horizontal[2*i-1].st = horizontal[2*i].st = x1;
        horizontal[2*i-1].ed = horizontal[2*i].ed = x2;
        horizontal[2*i-1].loc = y1; horizontal[2*i-1].lower = 1;
        horizontal[2*i].loc = y2;horizontal[2*i].lower = 0;

        vertical[2*i-1].st = vertical[2*i].st = y1;
        vertical[2*i-1].ed = vertical[2*i].ed = y2;
        vertical[2*i-1].loc = x1; vertical[2*i-1].lower = 1;
        vertical[2*i].loc = x2;vertical[2*i].lower = 0;
    }

    quicksort(vertical, 1, 2*N);
    quicksort(horizontal, 1, 2*N);

    for(int i = 1; i <= 2*N; ++i){
        if(horizontal[i].lower == 1){
            for(int k = horizontal[i].st; k < horizontal[i].ed; ++k){
                if(sig1[k] == 0) ++output;
                ++sig1[k];
            }
        }
        else{
            for(int k = horizontal[i].st; k < horizontal[i].ed; ++k){
                --sig1[k];
                if(sig1[k] == 0) ++output;
            }
        }
    }

    for(int i = 1; i <= 2*N; ++i){
        if(vertical[i].lower == 1){
            for(int k = vertical[i].st; k < vertical[i].ed; ++k){
                if(sig2[k] == 0) ++output;
                ++sig2[k];
            }
        }
        else{
            for(int k = vertical[i].st; k < vertical[i].ed; ++k){
                --sig2[k];
                if(sig2[k] == 0) ++output;
            }
        }
    }

    cout << output << endl;

//     for(int i = 1; i <= 2*N; ++i){
//        cout << vertical[i].loc << ' ';
//     }

    return 0;
}

关于线段树可参考 陈宏《数据结构的选择与算法效率——从IOI98试题PICTURE谈起》