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

蒟蒻被卡了很久…………

I. 题意：

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

II. 题解：

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

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

    方法一：暴力枚举，时间复杂度$O(N^3Q)$。使用前缀和优化暴力，时间复杂度可降至$O(N^2Q)$。

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

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

    设

$$sum(i,j) = \sum_{k = i}^{j}{A_k} \\ maxsum(i,j) = \max_{k = i}^{j}{\{sum(i,k)\}}$$     即 $sum(i,j)$ 为 $A[i..j]$ 的和， $maxsum(i,j)$ 为以 $A_i$ 开头，结尾位置不超过 $A_j$ 的最大连续子段和。设询问 $[L,R]$ 的答案为 $Ans(L, R)$ ，则有： $$Ans(L,R) = \max_{s = L}^{R}{\{maxsum(s, R)\}}$$

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

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

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

2. 那这道题呢：

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

III. 代码走起

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

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
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;
}