[BZOJ3845] ZCC loves Minecraft

不得不说出题人的创意特赞！
题面翻译(BZOJ的英文题能不能带翻译QaQ我一开始没看见多组数据):
在一个平面直角坐标系中，有一些关键点，坐标都是整数。现在要求你构造一个点集：
1.包含了所有关键点
2.允许由无数个点叠成一条线段，或是平面
3.任意一条平行于x轴或y轴的直线，与这个点集的公共部分，必须是：空，一个点，或连续的一条线段(也就是中间不能断)
4.满足1,3的条件下，使点集中的平面的面积最小

现在一开始平面上没有关键点，N次操作，每次加入一个关键点，输出N行，每行代表此时的点集的最小面积

题目保证，在任意时刻，整个点集一定是联通的，也就是保证不存在一个不联通的点集满足1和3

设所有x的最小值是lmost,最大值是rmost。根据3性质，对于一条直线X=x0，它与点集的公共部分是线段

(x0,DOWNx0)−−−(x0,UPx0)(lmost<=x<=rmost)

以UP[lmost..rmost]为例，因为3性质，不存在一个i使得

UPi−1>UPi<UPi+1(lmost<i<rmost)

也就是说，UP一定是一个先不下降，后不上升的序列。同理，DOWN先不上升后不下降

当你新加入一个关键点导致UP改变时，有如下两种情况//设原先的y最大值是T
图1是y<=T 图2是Y>T 的情况。

于是我们可以考虑对于所有整数lmost<=X<=rmost，用线段树维护一个UP(DOWN)序列，支持以下操作：
1.区间(单点)变成同一个数
2.询问一个位置X，求X左侧/右侧最近的且>=UP[X]的UP[ANS]

然而怎么得到输出的答案？

先令所有DOWN=0，UP都>0

ANS=∑i=lmostrmost−1min(UP[i],UP[i+1])

上式的正确性是显而易见的，又因为UP是先不降后不升序列，设UP[mid]是最大值，那么：

min(UP[i],UP[i+1])=UP[i](i<mid)

min(UP[i],UP[i+1])=UP[i+1](i>=mid)

结合上式，

ANS=(∑i=lmostrmostUP[i])−maxi=rmosti=lmostUP[i]

那么如果有DOWN存在，结论也是很容易的：

ANS=(∑i=lmostrmostUP[i])−(∑i=lmostrmostDOWN[i])−maxrmosti=lmostUP[i]+minrmosti=lmostDOWN[i]

你可以把DOWN记成相反数，那么只要让你的线段树兹磁区间和询问和区间最大值询问就可以啦！
代码长度不忍直视>_<

#include <cstdio>
template <typename Int> inline Int max(Int x, Int y) { return x > y ? x : y; }
template <typename Int> inline Int min(Int x, Int y) { return x < y ? x : y; }
int I()
{
    char c = getchar();
    int r = 0, f = 0;
    while ((c < 48 or c > 57) && c != '-')
        c = getchar();
    if (c == '-')
        f = 1, c = getchar();
    while (c > 47 && c < 58)
        r = (r << 3) + r + r + c - 48, c = getchar();
    return f ? -r : r;
}
class segmentTree
{
    public:
    void PUT(int x, int y)
    {
        if (QMax(x, x) < y)
        {
            if (y <= SegMax[1])
            {
                int LMt = x > -100000 ? (Ql = -100000, Qr = x - 1, Qw = y, RMostLarger(1, -100000, 100000)) : -1234321237, RMt = x < 100000 ? (Ql = x + 1, Qr = 100000, Qw = y, LMostLarger(1, -100000, 100000)) : 1234321237;
                if (LMt != -1234321237)
                    Same(LMt + 1, x, y);
                else
                    Same(x, RMt - 1, y);
            }
            else
            {
                int TOPp = MaxPosition(), X = leaf_ref[TOPp], Y = SegMax[TOPp];
                if (X < x)
                    Same(X, x - 1, Y);
                if (X > x)
                    Same(x + 1, X, Y);
                Set(x, y);
            }
        }
    }
    void init() { __init(1, -100000, 100000); }
    void Set(int x, int d) { M(x, d); }
    void Same(int l, int r, int d) { Ql = l, Qr = r, Qw = d, P(1, -100000, 100000); }
    int QMax(int l, int r) { Ql = l, Qr = r; return G(1, -100000, 100000); }
    long long QSum(int l, int r) { Ql = l, Qr = r; return S(1, -100000, 100000); }
    int MaxPosition()
    {
        int p = 1;
        while (Size[p] > 1)
        {
            Down(p);
            if (SegMax[p] == SegMax[p + p])
                p <<= 1;
            else
                p = p + p + 1;
        }
        return p;
    }
    private:
    int RMostLarger(int p, int l, int r)
    {
        if (SegMax[p] < Qw)
            return -1234321237;
        if (Ql <= l && r <= Qr)
        {
            int m;
            while (Size[p] > 1)
            {
                m = l + r >> 1;
                Down(p);
                if (SegMax[p + p + 1] >= Qw)
                    l = m + 1, p = p + p + 1;
                else
                    r = m, p <<= 1;
            }
            return leaf_ref[p];
        }
        int __, m = l + r >> 1;
        if (Qr > m)
            if ((__ = RMostLarger(p + p + 1, m + 1, r)) != -1234321237)
                return __;
        return Ql <= m ? RMostLarger(p + p, l, m) : -1234321237;
    }
    int LMostLarger(int p, int l, int r)
    {
        if (SegMax[p] < Qw)
            return 1234321237;
        if (Ql <= l && r <= Qr)
        {
            int m;
            while (Size[p] > 1)
            {
                m = l + r >> 1;
                Down(p);
                if (SegMax[p + p] >= Qw)
                    r = m, p <<= 1;
                else
                    l = m + 1, p = p + p + 1;
            }
            return leaf_ref[p];
        }
        int __, m = l + r >> 1;
        if (Ql <= m)
            if ((__ = LMostLarger(p + p, l, m)) != 1234321237)
                return __;
        return Qr > m ? LMostLarger(p + p + 1, m + 1, r) : 1234321237;
    }
    int Ql, Qr, Qw;
    int SegMax[555555], SameTag[555555], Size[555555], leaf_ref[555555];
    long long SegSum[555555];
    void __init(int p, int l, int r)
    {
        Size[p] = r - l + 1;
        if (l < r)
        {
            int m = l + r >> 1;
            __init(p + p, l, m);
            __init(p + p + 1, m + 1, r);
        }
        else
            leaf_ref[p] = l;
    }
    void Up(int p)
    {
        SegMax[p] = max(SegMax[p + p], SegMax[p + p + 1]);
        SegSum[p] = SegSum[p + p] + SegSum[p + p + 1];
    }
    void Down(int p)
    {
        if (SameTag[p])
        {
            SameTag[p] = 0;
            SameTag[p + p] = SameTag[p + p + 1] = 1;
            SegMax[p + p] = SegMax[p + p + 1] = SegMax[p];
            SegSum[p + p] = (long long)Size[p + p] * SegMax[p];
            SegSum[p + p + 1] = (long long)Size[p + p + 1] * SegMax[p];
        }
    }
    int Find(int x)
    {
        int p = 1, l = -100000, r = 100000, m;
        Down(p);
        while (l < r)
        {
            Down(p);
            m = l + r >> 1;
            if (x <= m)
                r = m, p <<= 1;
            else
                l = m + 1, p = p + p + 1;
        }
        return p;
    }
    void P(int p, int l, int r) // makeSame
    {
        if (Ql <= l && r <= Qr)
            SameTag[p] = 1, SegMax[p] = Qw, SegSum[p] = (long long)Size[p] * Qw;
        else
        {
            int m = l + r >> 1;
            Down(p);
            if (Ql <= m)
                P(p + p, l, m);
            if (Qr > m)
                P(p + p + 1, m + 1, r);
            Up(p);
        }
    }
    int G(int p, int l, int r) // get the largest
    {
        if (Ql <= l && r <= Qr)
            return SegMax[p];
        Down(p);
        int m = l + r >> 1;
        int Le = Ql <= m ? G(p + p, l, m) : 0, Ri = Qr > m ? G(p + p + 1, m + 1, r) : 0;
        return max(Le, Ri);
    }
    void M(int x, int d) // a[x] := d
    {
        int p = Find(x);
        SegMax[p] = SegSum[p] = d, SameTag[p] = 0;
        while (p > 1)
            p >>= 1, Up(p);
    }
    long long S(int p, int l, int r) // get the sum
    {
        if (Ql <= l && r <= Qr)
            return SegSum[p];
        Down(p);
        int m = l + r >> 1;
        long long Le = Ql <= m ? S(p + p, l, m) : 0, Ri = Qr > m ? S(p + p + 1, m + 1, r) : 0;
        return Le + Ri;
    }
}UP, DOWN;
int main()
{
    UP.init(), DOWN.init();
    int Q;
    while (scanf("%d", &Q) != EOF)
    {
        int lmost = 10000000, rmost = -10000000;
        UP.Same(-100000, 100000, 0), DOWN.Same(-100000, 100000, 0);
        while (Q--)
        {
            int x = I(), y = I();
            UP.PUT(x, 200000 + y), DOWN.PUT(x, 200000 - y);
            if (x < lmost)
                lmost = x;
            if (x > rmost)
                rmost = x;
            printf("%lld\n", UP.QSum(-100000, 100000) + DOWN.QSum(-100000, 100000) - UP.QMax(-100000, 100000) - DOWN.QMax(-100000, 100000) - 400000ll * (rmost - lmost));
        }
    }
    return 0;
}