「在更」初涉历史最值线段树

历史最值线段树好像听上去很简单，多带几个参数就可以了？　吗？

历史最值线段树

正如其名，「历史最值线段树」记录的是区间内的历史最值。

HistoricalMaxVal == max(Tree[i].val)？

听上去是不是很简单啊？是不是我们每次记录一下max就好了啊？

好吧不讲这个正常人不会认可的想法了。

记录当前最大值mx？

那么我们记录一下当前区间的最大值$mx$，然后每一次操作这个区间的时候用$HistoricalMaxVal=max(mx+add)$更新一下怎么样？

是的，这样对于线段树单个节点来说正确性是有了。但是我们怎么向下传递呢？

我们都知道线段树区间操作为了效率是要$pushdown$操作的。但如果按照这种思路，我们只能够更新区间而无法向下传递！

可能有点抽象，举个例子：

a[]:1 2 3 4 5
add 1 5 15
add 1 5 -15
query 3 5

这里我们先对$[1,5]$加上15，再对$[1,5]$减去15，最后查询$[3,5]$的历史最大值。

如果对于每一个区间我们只记录$mx,hisMx$这两个数，上面例子里的前两个操作都只是对于线段树的root($[1,5]$这个区间)操作，并且最终记录下来$add=0,his=15$。可是$[1,5]$记录下来的正确的最大值又有什么用呢？我们查询的是$[3,5]$，这样一来查询出来的答案就变成$5$了。

几道例题

bzoj3064: Tyvj 1518 CPU监控

Description

Bob需要一个程序来监视CPU使用率。这是一个很繁琐的过程，为了让问题更加简单，Bob会慢慢列出今天会在用计算机时做什么事。
Bob会干很多事，除了跑暴力程序看视频之外，还会做出去玩玩和用鼠标乱点之类的事，甚至会一脚踢掉电源……这些事有的会让做这件事的这段时间内CPU使用率增加或减少一个值；有的事还会直接让CPU使用率变为一个值。
当然Bob会询问：在之前给出的事件影响下，CPU在某段时间内，使用率最高是多少。有时候Bob还会好奇地询问，在某段时间内CPU曾经的最高使用率是多少。
为了使计算精确，使用率不用百分比而用一个整数表示。
不保证Bob的事件列表出了莫名的问题，使得使用率为负………………

Input

第一行一个正整数T，表示Bob需要监视CPU的总时间。
然后第二行给出T个数表示在你的监视程序执行之前，Bob干的事让CPU在这段时间内每个时刻的使用率达已经达到了多少。
第三行给出一个数E，表示Bob需要做的事和询问的总数。
接下来E行每行表示给出一个询问或者列出一条事件：
Q X Y:询问从X到Y这段时间内CPU最高使用率
A X Y:询问从X到Y这段时间内之前列出的事件使CPU达到过的最高使用率
P X Y Z:列出一个事件这个事件使得从X到Y这段时间内CPU使用率增加Z
C X Y Z:列出一个事件这个事件使得从X到Y这段时间内CPU使用率变为Z
时间的单位为秒，使用率没有单位。
X和Y均为正整数（X<=Y），Z为一个整数。
从X到Y这段时间包含第X秒和第Y秒。
保证必要运算在有符号32位整数以内。 

Output

对于每个询问，输出一行一个整数回答。

HINT 

数据分布如下：
第1、2个数据保证T和E均小于等于1000
第3、4个数据保证只有Q类询问
第5、6个数据保证只有C类事件
第7、8个数据保证只有P类事件
全部数据保证T和E均小于等于100000

---

题目分析

虽然说是板子题但是调了一晚上……

先把代码挂这里

注释掉的部分不是调试部分，就是打挂的细节处理。

#include<bits/stdc++.h>
const int INF = 2147483647;
const int maxn = 100035;

struct node
{
    int hisMx,mx;
    int cg,add,cgMx,addMx;
    bool ce;
}f[maxn<<2];
int n,m;

int read()
{
    int num = 0;
    char ch = getchar();
    bool fl = 0;
    for (; !isdigit(ch); ch = getchar())
        if (ch=='-') fl = 1;
    for (; isdigit(ch); ch = getchar())
        num = (num<<1)+(num<<3)+ch-48;
    if (fl) num = -num;
    return num;
}
void pushup(int rt)
{
    f[rt].mx = std::max(f[rt<<1].mx, f[rt<<1|1].mx);
    // f[rt].hisMx = std::max(f[rt].mx, f[rt].hisMx);
    f[rt].hisMx = std::max(f[rt<<1].hisMx, f[rt<<1|1].hisMx);
}
void pushdown(int rt)
{
    // printf("pushdownINFO:
");
    for (int i=0; i<=1; i++)
    {
        int x = rt<<1|i;
        f[x].hisMx = std::max(f[x].hisMx, std::max(f[rt].cgMx, f[x].mx+f[rt].addMx));
        if (f[x].cg!=-INF) f[x].cgMx = std::max(f[x].cgMx, f[x].cg+f[rt].addMx);
        else f[x].addMx = std::max(f[x].addMx, f[x].add+f[rt].addMx);
        // if (f[rt].cg){
        //     f[x].add = 0;
        //     f[x].ce = 1, f[x].mx = f[x].cg = f[rt].cg;
        //     f[x].cgMx = std::max(f[x].cg, f[x].cgMx);
        // }
        // if (f[rt].add){
        //     f[x].add += f[rt].add;
        // }
        // f[x].hisMx = std::max(f[x].hisMx, std::max(f[x].cgMx, f[x].mx+f[x].addMx));
        if (f[rt].add){
            if (f[x].cg!=-INF) f[x].cg += f[rt].add;
            else f[x].add += f[rt].add;
            f[x].mx += f[rt].add;
        }
        // if (f[rt].ce){
        if (f[rt].cg!=-INF){
            f[x].mx = f[x].cg = f[rt].cg;
            f[x].add = 0;
        }
        f[x].addMx = std::max(f[x].addMx, f[x].add);
        f[x].cgMx = std::max(f[x].cgMx, std::max(f[x].cg, f[rt].cgMx));
        // printf("%d: addMx:%d cgMx:%d hisMx:%d
",i,f[x].addMx,f[x].cgMx,f[x].hisMx);
    }
    // puts("");
    f[rt].add = f[rt].addMx = 0;
    f[rt].ce = 0, f[rt].cg = f[rt].cgMx = -INF;
}
void build(int rt, int l, int r)
{
    f[rt].cg = f[rt].cgMx = -INF;
    if (l==r){
        f[rt].hisMx = f[rt].mx = read();
        // f[rt].cg = f[rt].cgMx = -INF;
        return;
    }
    int mid = (l+r)>>1;
    build(rt<<1, l, mid), build(rt<<1|1, mid+1, r);
    pushup(rt);
    return;
}
int queryMx(int rt, int L, int R, int l, int r)
{
    if (l!=r) pushdown(rt);
    if (L <= l&&r <= R) return f[rt].mx;
    int mid = (l+r)>>1, ret = -INF;
    if (L <= mid) ret = std::max(ret, queryMx(rt<<1, L, R, l, mid));
    if (R > mid) ret = std::max(ret, queryMx(rt<<1|1, L, R, mid+1, r));
    return ret;
}
int queryHis(int rt, int L, int R, int l, int r)
{
    if (l!=r) pushdown(rt);
    if (L <= l&&r <= R) return f[rt].hisMx;
    int mid = (l+r)>>1, ret = -INF;
    if (L <= mid) ret = std::max(ret, queryHis(rt<<1, L, R, l, mid));
    if (R > mid) ret = std::max(ret, queryHis(rt<<1|1, L, R, mid+1, r));
    return ret;
}
void updateAdd(int rt, int L, int R, int l, int r, int c)
{
    if (l!=r) pushdown(rt);
    if (L <= l&&r <= R){
        f[rt].add += c, f[rt].mx += c;
        // f[rt].addMx = std::max(f[rt].addMx, f[rt].add);
        f[rt].addMx += c;
        f[rt].hisMx = std::max(f[rt].mx, f[rt].hisMx);
        return;
    }
    int mid = (l+r)>>1;
    if (L <= mid) updateAdd(rt<<1, L, R, l, mid, c);
    if (R > mid) updateAdd(rt<<1|1, L, R, mid+1, r, c);
    pushup(rt);
    return;
}
void updateCover(int rt, int L, int R, int l, int r, int c)
{
    if (l!=r) pushdown(rt);
    if (L <= l&&r <= R){
        // f[rt].add = 0;
        f[rt].ce = 1;
        f[rt].cgMx = f[rt].mx = f[rt].cg = c;
        f[rt].hisMx = std::max(f[rt].mx, f[rt].hisMx);
        return;
    }
    int mid = (l+r)>>1;
    if (L <= mid) updateCover(rt<<1, L, R, l, mid, c);
    if (R > mid) updateCover(rt<<1|1, L, R, mid+1, r, c);
    pushup(rt);
    return;
}
int main()
{
    n = read();
    build(1, 1, n);
    m = read();
    while (m--)
    {
        char ch[5];
        scanf("%s",ch);
        int x = read(), y = read(), z;
        if (ch[0]=='Q')
            printf("%d
",queryMx(1, x, y, 1, n));
        else if (ch[0]=='A')
            printf("%d
",queryHis(1, x, y, 1, n));
        else{
            z = read();
            if (ch[0]=='P')
                updateAdd(1, x, y, 1, n, z);
            else updateCover(1, x, y, 1, n, z);
        }
    }
    return 0;
}