[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 <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;
}