SPOJ GSS2 Can you answer these queries II

很好的一道题，想了很久。首先突破的是，可以找到枚举其中一边，假设是尾部y，然后快速找出满足条件的最大的头部x，连续区间的和

很容易想到借助部分和的思想，如果是从y开始往前面累加，那么就是一个关于y的后缀和。

如果答案的一边在y，那么就转化成了对后缀和的RMQ。

y的后缀和y-1或者y+1的后缀是差不多的，只要想想怎么递推就好了。

y == 0时的所有后缀是很容易得到的，因此考虑用y递推y+1，这个后缀和是从右边往左累加的，重复的不算，

对于元素a[y+1]，它所影响的后缀只有y+1到a[y+1]上一次出现的位置，区间更新就好了。

然后就卡了，经过鼠宝宝提醒才想到，在上面过程中可以再维护一个历史最值，这个历史最值怎么维护也是各种纠结。。。

最容易想到的是在线段树区间更新的时候，当前max改变的时候用来更新历史最值，但是因为是区间更新，需要打标记，

而打上标记的子节点的历史最值实际上没有更新到，因此对于历史最值的更新也打上一个标记。

/*********************************************************
*            ------------------                          *
*   author AbyssalFish                                   *
**********************************************************/
#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<queue>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>
#include<numeric>
using namespace std;


typedef long long ll;
const int MAX_N = 1e5+5;



int dat[MAX_N*2];
int *const ps = dat + MAX_N;
int a[MAX_N];


const int MAX_M = MAX_N;

template<typename T>
struct LIST
{
    int hd[MAX_N];
    int nx[MAX_M];
    T val[MAX_M];
    int sz;
    void init(int n)
    {
        memset(hd+1,0,sizeof(int)*n); sz = 0;
    }
    void add(int u, const T &v)
    {
        nx[++sz] = hd[u];
        val[sz] = v;
        hd[u] = sz;
    }
};


LIST<int> lyx;

int N;

#define para int o = 1, int l = 1, int r = N
#define lo (o<<1)
#define ro (o<<1|1)
#define Tvar int md = (l+r)>>1;
#define lsn lo,l,md
#define rsn ro,md+1,r
#define insd ql<=l&&r<=qr

const int ST_SIZE = 1<<18;

ll dwn[ST_SIZE];
ll mx[ST_SIZE];
ll his_mx[ST_SIZE];
ll his_dwn[ST_SIZE];


inline void sink_his(int o, ll d)
{
    his_dwn[o] = max(his_dwn[o], dwn[o] + d);//历史最值更新的标记也是取最大的
    his_mx[o] = max(his_mx[o], mx[o] + d);
}

inline void sink(int o,ll d)
{
    mx[o] += d;
    dwn[o] += d;
}

inline void push_down(int o)
{
    ll &d = his_dwn[o];
    if(d){ //子节点还没更新，保存的是旧值
        sink_his(lo,d);
        sink_his(ro,d);
        d = 0;
    }

    ll &d2 = dwn[o];
    if(d2){
        sink(lo,d2);
        sink(ro,d2);
        d2 = 0;
    }
}

int ql,qr;
ll q_dlt;
void modify(para)
{
    if(insd){
        sink(o,q_dlt);
        his_dwn[o] = max(his_dwn[o], dwn[o]);
        his_mx[o] = max(his_mx[o], mx[o]);
    }
    else {
        Tvar
        push_down(o);
        if(ql <= md) modify(lsn);
        if(qr > md) modify(rsn);
        mx[o] = max(mx[lo],mx[ro]);
        his_mx[o] = max(mx[o], his_mx[o]);
    }
}

ll q_his_mx(para)
{
    if(insd) return his_mx[o];
    else {
        Tvar
        push_down(o);
        ll re = -INFINITY;
        if(ql <= md) re = max(re,q_his_mx(lsn));
        if(qr > md) re = max(re,q_his_mx(rsn));
        return re;
    }
}


ll ans[MAX_N];

void solve()
{
    int i;
    for(i = 1; i <= N; i++){
        scanf("%d", a+i);
    }

    int Q; scanf("%d",&Q);
    int x, y;
    for(i = 1; i <= Q; i++){
        scanf("%d%d",&x, &y);
        lyx.add(y,x);
    }

    for(y = 1; y <= N; y++){
        ql = ps[a[y]]+1;
        qr = y;
        q_dlt = a[y];
        ps[a[y]] = y;
        modify();
        for(i = lyx.hd[y]; i; i = lyx.nx[i]){
            ql = lyx.val[i];
            ans[i] = q_his_mx();
        }
    }

    for(i = 1; i <= Q; i++){
        printf("%lld\n", ans[i]);
    }
}

//#define LOCAL
int main()
{
#ifdef LOCAL
    freopen("in.txt","r",stdin);
#endif
    //cout<<(((int)ceil(log2(MAX_N))+1))<<endl;
    scanf("%d",&N);
    solve();

    return 0;
}