[SPOJ1557][GSS2][线段树]Can you answer these queries II[好题]

蒟蒻被卡了很久…………

I. 题意：

    一个长度为 N(1⩽N⩽100000) 的序列 {Ai}(−100000⩽Ai⩽100000) ；同时给出 Q(1⩽Q⩽100000) 组询问；每组询问给出两个正整数 L,R 要求你在 A[L..R] 中找出和最大的连续子序列；有趣坑爹的是，在计算子序列的和时，相同的数只会被计算一次（举个例子，即 sum({1,−2,1,3})=2 ）。

II. 题解：

1. 先看一个简单的情况：

    如果没有“相同的数只会被计算一次”这个限制条件，我们应该怎么做？

    方法一：暴力枚举，时间复杂度 O(N3Q) 。使用前缀和优化暴力，时间复杂度可降至 O(N2Q) 。

    方法二：贪心，时间复杂度 O(NQ) 。

    显然以上两种方法都不行。我们考虑以下做法：

    设

sum(i,j)=∑k=ijAkmaxsum(i,j)=maxk=ij{sum(i,k)}

    即 sum(i,j) 为 A[i..j] 的和， maxsum(i,j) 为以 Ai 开头，结尾位置不超过 Aj 的最大连续子段和。设询问 [L,R] 的答案为 Ans(L,R) ，则有：

Ans(L,R)=maxs=LR{maxsum(s,R)}

    显然，我们可以从 sum(i,j),maxsum(i,j) 以及 Aj+1 以 O(1) 的时间复杂度推出 sum(i,j+1),maxsum(i,j+1) 的值。所以上述算法的时间复杂度为 O(N2Q) （枚举序列开头 s ）。

    优化1：注意到在一次询问 [L,R] 中， Ai 可以用来更新 sum(L,i),sum(L+1,i),...,sum(i,i) 。我们顺序处理 A[L..R] 中每个数，将 sum 函数减小一维，以 sum(i) 表示从 Ai 到当前处理的数之和。显然可以用线段树维护 sum(i) ，处理一个数 Ai 等价于一次区间加值（ sum(L)∼sum(i) 加上 Ai ）， maxsum(i,R) 即为 sum(i) 的历史最大值。时间复杂度 O(NQlogN)

    优化2：注意到在多组询问中有很多重复计算的部分。依次处理 A[1..N] 中每个数（方法同上，加值的区间变成 sum(1)∼sum(i) ），一次询问 [L,R] 就变成了在处理 AR 后查询 sum(L)∼sum(R) 的历史最大值，我们把询问按右端点排序，可以做到每个数只处理一次。总时间复杂度 O((N+Q)logN) 。

2. 那这道题呢：

     考虑到刚才那种做法如果照搬会造成的问题：相同数字被算了几次。对于一个数 Ai ，假设它上一个相同的数是 Aj ，那么处理到 Ai 时， sum(1)∼sum(j) 都已经处理过这个数字了，所以不能再加一次，只能给 sum(j+1)∼sum(i) 加上 Ai 。这样就能做到不重复了。总时间复杂度 O((N+Q)logN) 。

III. 代码走起

（不要随便看代码。不要随便看代码。不要随便看代码。重要的事情说三遍。 ）
（代码细节自己推敲，或者看类似的题的题解。类似这样要求维护历史最值的线段树题目不少。）

#include 
#include 
#include 
#include 
#include 
using namespace std;

//Global Variables & Definitions
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
#define MS(arr, x) memset(arr, x, sizeof(arr))

#define MAXN 100010
#define MAXQ 100010
#define MAXV 100010

int N, Q;
int A[MAXN];

struct Query {
    int I; //Index
    int X, Y;
} Qs[MAXQ];

bool QCompY(Query a, Query b) { return a.Y < b.Y; }
bool QCompI(Query a, Query b) { return a.I < b.I; }

int _P[MAXV * 2]; //P[i]: last place i appeared
int *P;

int ans[MAXN];
//End Global Variables & Definitions

//Segment Tree
#define DEFINE_MID int mid = (l + r) >> 1
#define lson ((u) << 1)
#define rson ((u) << 1 | 1)

#define MAXT (MAXN << 2)
int m[MAXT];
int hm[MAXT];
int lazy[MAXT], hmlazy[MAXT];

void PushUp(int u) {
    m[u] = max(m[lson], m[rson]);
    hm[u] = max(hm[lson], hm[rson]);
    hm[u] = max(hm[u], m[u]);
}

void PushDown(int u) {
    if(!(lazy[u] | hmlazy[u])) return;

    hmlazy[lson] = max(hmlazy[lson], lazy[lson] + hmlazy[u]);
    hmlazy[rson] = max(hmlazy[rson], lazy[rson] + hmlazy[u]);

    hm[lson] = max(hm[lson], m[lson] + hmlazy[u]);
    hm[rson] = max(hm[rson], m[rson] + hmlazy[u]);

    lazy[lson] += lazy[u];
    lazy[rson] += lazy[u];

    m[lson] += lazy[u];
    m[rson] += lazy[u];

    lazy[u] = hmlazy[u] = 0;
}

void MakeLazy(int u, int v) {
    lazy[u] += v;
    m[u] += v;
    hmlazy[u] = max(hmlazy[u], lazy[u]);
    hm[u] = max(hm[u], m[u]);
}

void Build(int u, int l, int r) {
    //m[u] = hm[u] = lazy[u] = hmlazy[u] = 0;
    if(l == r) return;

    DEFINE_MID;
    Build(lson, l, mid);
    Build(rson, mid + 1, r);
}

void Add(int u, int l, int r, int L, int R, int v) {
    if(L <= l && R >= r) {
        MakeLazy(u, v); return;
    }

    PushDown(u);
    DEFINE_MID;
    if(L <= mid) Add(lson, l, mid, L, R, v);
    if(R > mid) Add(rson, mid + 1, r, L, R, v);

    PushUp(u);
}

int Query(int u, int l, int r, int L, int R) { //Query historical maximum in [L, R]
    if(L <= l && R >= r) {
        return hm[u];
    }

    PushDown(u);
    DEFINE_MID;

    int temp = -1;
    if(L <= mid) temp = max(temp, Query(lson, l, mid, L, R));
    if(R > mid) temp = max(temp, Query(rson, mid + 1, r, L, R));
    return temp;
}
//End Segment Tree

//Main Structure
inline void Deal(int v, int p) {
    Add(1, 1, N, P[v] + 1, p, v);
    P[v] = p;
}

inline void ir() {
    //MS(_P, 0);
    P = _P + MAXV;

    //Read
    scanf("%d", &N);
    for(int i = 1;i <= N;++i) scanf("%d", &A[i]);

    scanf("%d", &Q);
    for(int i = 0;i < Q;++i) {
        scanf("%d%d", &Qs[i].X, &Qs[i].Y);
        Qs[i].I = i;
    }

    sort(Qs, Qs + Q, QCompY);

    Build(1, 1, N);
}

int main() {
    ir();

    int ptr = 0; //The last one dealed
    for(int i = 0;i < Q;++i) {
        int TX = Qs[i].X, TY = Qs[i].Y;

        while(ptr < TY) {
            ++ptr;
            Deal(A[ptr], ptr);
        }

        //Qs[i].X = Query(1, 1, N, TX, TY);
        ans[Qs[i].I] = Query(1, 1, N, TX, TY);
    }

    //sort(Qs, Qs + Q, QCompI);
    //for(int i = 0;i < Q;++i) printf("%d\n", Qs[i].X);
    for(int i = 0;i < Q;++i) printf("%d\n", ans[i]);
    return 0;
}