HDOJ 3255 Farming（扫描线 + 线段树 体积的并）

题意：

有一块田，上面有n个矩阵，每个矩阵对应一个权值，矩阵相交的部分取权值大的，问最后能获得多少值。

思路：

1. 权值问题可以转换为体积问题，因为相同格子里面权值大的胜，可以把权值看成是立方体的高，于是问题转换为立方体体积的并。

2. 和 get the treasure 题目类似，因为price变化的范围很小，于是先对高进行离散化 + 扫描。

3. 剩下的就是求 面积 * 高 了，对于面积，采取以前的常规手段，对 x 进行离散化，然后求面积的并就OK了。

 

#include <iostream>

#include <algorithm>

using namespace std;



#define lhs l, m, rt << 1

#define rhs m + 1, r, rt << 1 | 1



const int maxn = 61000;

int sum[maxn << 2], cnt[maxn << 2];

int price[10];

int xcord[maxn];



struct Coord {

    int x1, y1, x2, y2, p;

} cord[30010] ;



struct Segment {

    int l, r, h, v;



    Segment () { }

    Segment(int _l, int _r, int _h, int _v) 

        : l(_l), r(_r), h(_h), v(_v) { }



    bool operator < (const Segment& other)

    {

        if (h == other.h)

            return v > other.v;

        else

            return h < other.h;

    }

} seg[maxn] ;



void pushUp(int l, int r, int rt)

{

    if (cnt[rt])

        sum[rt] = xcord[r+1] - xcord[l];

    else if (l == r)

        sum[rt] = 0;

    else

        sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];

}



void update(int beg, int end, int value, int l, int r, int rt)

{

    if (beg <= l && r <= end)

    {

        cnt[rt] += value;

        pushUp(l, r, rt);

        return ;

    }

    int m = (l + r) >> 1;

    if (beg <= m)

        update(beg, end, value, lhs);

    if (end > m)

        update(beg, end, value, rhs);



    pushUp(l, r, rt);

}



__int64 solve(int nn, int mm)

{

    __int64 ret = 0;



    sort(price + 1, price + mm + 1);



    for (int i = 1; i <= mm; ++i)

    {

        int n = 0, m = 0;

        for (int j = 0; j < nn; ++j)

        {

            if (cord[j].p >= price[i])

            {

                seg[n++] = Segment(cord[j].x1, cord[j].x2, cord[j].y1, 1);

                seg[n++] = Segment(cord[j].x1, cord[j].x2, cord[j].y2, -1);

                xcord[m++] = cord[j].x1;

                xcord[m++] = cord[j].x2;

            }

        }

        sort(seg, seg + n);

        sort(xcord, xcord + m);



        m = unique(xcord, xcord + m) - xcord;



        memset(sum, 0, sizeof(sum));

        memset(cnt, 0, sizeof(cnt));



        __int64 area = 0;

        for (int j = 0; j < n - 1; ++j)

        {

            int beg = lower_bound(xcord, xcord + m, seg[j].l) - xcord;

            int end = lower_bound(xcord, xcord + m, seg[j].r) - xcord - 1;

            if (beg <= end)

                update(beg, end, seg[j].v, 0, m - 1, 1);



            area += (__int64)sum[1] * (seg[j+1].h - seg[j].h);

        }

        ret += area * (price[i] - price[i-1]);

    }

    return ret;

}



int main()

{

    int cases, cc = 0;

    scanf("%d", &cases);



    while (cases--)

    {

        int n, m;

        scanf("%d %d", &n, &m);



        price[0] = 0;

        for (int i = 1; i <= m; ++i)

            scanf("%d", &price[i]);

        for (int i = 0; i < n; ++i)

        {

            scanf("%d %d %d %d %d", &cord[i].x1, &cord[i].y1, &cord[i].x2, &cord[i].y2, &cord[i].p);

            cord[i].p = price[cord[i].p];

        }



        printf("Case %d: %I64d\n", ++cc, solve(n, m));

    }

    return 0;

}