Picture POJ - 1177 线段树+离散化+扫描线 求交叉图像周长

参考  https://www.cnblogs.com/null00/archive/2012/04/22/2464876.html

#include <stdio.h>
#include <algorithm>
#define LEN 10000
using namespace std;

struct Node
{
    int left;
    int right;
    int count;//被覆盖次数
    //所包含的区间数量，如三条[1,2]，[2,3]，[4,5]线段被覆盖，则line=2，因为 [1,2]，[2,3]是连续的。
    int line;//所包含的区间数量
    int lbd;//左端点是否被覆盖   用来辅助对line的计算
    int rbd;//右端点是否被覆盖
    int m;//测度  ，即覆盖的区间长度，如[2,8]就为6
}node[LEN*];;
struct ScanLine
{
    int x;
    int y1;
    int y2;
    int flag;
}scan[LEN];;
int y[LEN];
void build(int l, int r, int i)
{
    node[i].left = l;
    node[i].right = r;
    node[i].count = ;
    node[i].m = ;
    node[i].line = ;
    if (r - l > )
    {
        int middle = (l + r)/;
        build(l, middle, *i + );
        build(middle, r, *i + );
    }
}
//更新测度m
void update_m(int i)
{
    if (node[i].count > )
        node[i].m = y[node[i].right] - y[node[i].left];
    else if (node[i].right - node[i].left == )
        node[i].m = ;
    else
    {
        node[i].m = node[*i + ].m + node[*i + ].m;
    }
}
//更新line
void update_line(int i)
{
    if (node[i].count > )
    {
        node[i].lbd = ;
        node[i].rbd = ;
        node[i].line = ;
    }
    else if (node[i].right - node[i].left == )
    {
        node[i].lbd = ;
        node[i].rbd = ;
        node[i].line = ;
    }
    else
    {
        node[i].lbd = node[*i + ].lbd;
        node[i].rbd = node[*i + ].rbd;
        node[i].line = node[*i + ].line + node[*i + ].line - node[*i + ].rbd*node[*i + ].lbd;
    }
}
void insert(int l, int r, int i)
{
    //在这里要取离散化之前的原值进行比较
    if (y[node[i].left] >= l && y[node[i].right] <= r)
        (node[i].count)++;
    else if (node[i].right - node[i].left == )
        return;
    else
    {
        int middle = (node[i].left + node[i].right)/;
        if (r <= y[middle])
            insert(l, r, *i + );
        else if (l >= y[middle])
            insert(l, r, *i + );
        else
        {
            insert(l, y[middle], *i + );
            insert(y[middle], r, *i + );
        }
    }
    update_m(i);
    update_line(i);
}

void remove(int l, int r, int i)
{
    ////在这里要取离散化之前的原值进行比较
    if (y[node[i].left] >= l && y[node[i].right] <= r)
        (node[i].count)--;
    else if (node[i].right - node[i].left == )
        return;
    else
    {
        int middle = (node[i].left + node[i].right)/;
        if (r <= y[middle])
            remove(l, r, *i + );
        else if (l >= y[middle])
            remove(l, r, *i + );
        else
        {
            remove(l, y[middle], *i + );
            remove(y[middle], r, *i + );
        }
    }
    update_m(i);
    update_line(i);
}

bool cmp(ScanLine line1,ScanLine line2)
{
    if (line1.x == line2.x)
        return line1.flag > line2.flag;
    return (line1.x < line2.x);
}

int main()
{
    int n;
    scanf("%d", &n);
    int x1, y1, x2, y2;
    int i = ;
    while (n--)
    {
        scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
        scan[i].x = x1;
        scan[i].y1 = y1;
        scan[i].y2 = y2;
        scan[i].flag = ;
        y[i++] = y1;
        scan[i].x = x2;
        scan[i].y1 = y1;
        scan[i].y2 = y2;
        scan[i].flag = ;
        y[i++] = y2;
    }
    sort(y, y + i);
    sort(scan, scan + i, cmp);
    //y数组中不重复的个数
    int unique_count = unique(y, y + i) - y;
    //离散化，建立线段树
    build(, unique_count - , );
    int perimeter = ;
    int now_m = ;
    int now_line = ;
    for (int j = ; j < i; j++)
    {
        if (scan[j].flag)
            insert(scan[j].y1, scan[j].y2, );
        else
            remove(scan[j].y1, scan[j].y2, );
        if (j >= )
            perimeter += *now_line*(scan[j].x - scan[j-].x);
        //要减去，因为一个边只能算一次，要减去上一次已经算过的边
        perimeter += abs(node[].m - now_m);
        now_m = node[].m;
        now_line = node[].line;
    }
    printf("%d\n", perimeter);
    return ;
}