E. Sum Over Zero

E. Sum Over Zero

You are given an array $a_1, a_2, \ldots, a_n$ of $n$ integers. Consider $S$ as a set of segments satisfying the following conditions.

• Each element of $S$ should be in form $[x, y]$, where $x$ and $y$ are integers between $1$ and $n$, inclusive, and $x \leq y$.
• No two segments in $S$ intersect with each other. Two segments $[a, b]$ and $[c, d]$ intersect if and only if there exists an integer $x$ such that $a \leq x \leq b$ and $c \leq x \leq d$.
• For each $[x, y]$ in $S$, $a_x+a_{x+1}+ \ldots +a_y \geq 0$.

The length of the segment $[x, y]$ is defined as $y-x+1$. $f(S)$ is defined as the sum of the lengths of every element in $S$. In a formal way, $f(S) = \sum_{[x, y] \in S} (y - x + 1)$. Note that if $S$ is empty, $f(S)$ is $0$.

What is the maximum $f(S)$ among all possible $S$?

Input

The first line contains one integer $n$ ($1 \leq n \leq 2 \cdot 10^5$).

The next line is followed by $n$ integers $a_1, a_2, \ldots, a_n$ ($-10^9 \leq a_i \leq 10^9$).

Output

Print a single integer, the maximum $f(S)$ among every possible $S$.

Examples

input

5
3 -3 -2 5 -4

output

4

input

10
5 -2 -4 -6 2 3 -6 5 3 -2

output

9

input

4
-1 -2 -3 -4

output

0

Note

In the first example, $S=\{[1, 2], [4, 5]\}$ can be a possible $S$ because $a_1+a_2=0$ and $a_4+a_5=1$. $S=\{[1, 4]\}$ can also be a possible solution.

Since there does not exist any $S$ that satisfies $f(S) > 4$, the answer is $4$.

In the second example, $S=\{[1, 9]\}$ is the only set that satisfies $f(S)=9$. Since every possible $S$ satisfies $f(S) \leq 9$, the answer is $9$.

In the third example, $S$ can only be an empty set, so the answer is $0$.

 

解题思路

　　比赛的时候想到了数据结构优化dp的做法，但没写出来。参考树状数组$/$线段树优化最长上升子序列的做法。

　　这道题本质就是要我们将序列分成若干个互不相交的区间，每个区间的和要求非负，区间的价值就是区间的长度，问在满足条件的划分方案中最大代价可以是多少。

　　定义状态$f(i)$表示考虑前$i$个数所有合法划分方案中区间长度总和的最大值，根据第$i$个数所在区间长度进行状态划分。如果不包含第$i$个数，那么$f(i) = f(i-1)$。如果包含第$i$个数，那么$f(i) = \max\limits_{0 \leq j < i \ \text{and} \ s_{i} - s_{j} \geq 0} \{ f(j) + i - j \}$，其中$s_i = \sum\limits_{j = 1}^{i}{a_j}$表示前缀和。

　　很明显这种做法的时间复杂度是$O(n^2)$，因此需要优化，优化的方法也是很经典。

　　注意到每次状态转移的时候本质是找到所有满足$s_j \leq s_i$的$j$，然后有$f(i) = \max \{ {f(j) + i - j} \}$，我们把$f(j) - j$看作一个整体，有$s_j$对应$f(j) - j$，而$i$是一个定值，那么就变成了在所有不超过$s_i$的$s_j$中，求一个最大的$f(j) - j$。也就是询问一个前缀的最大值，因此可以考虑用权值树状数组或者是权值线段树来维护，其中在$s_j$处存储$f(j) - j$。

　　状态转移方程变成了$f(i) = \max \{ {f(i-1), \text{query}(s_i) + i} \}$。其中由于$s_i$的取值范围很大，因此需要离散化。

　　树状数组做法，AC代码如下：

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N = 2e5 + 10;

LL s[N];
LL xs[N], sz;
int tr[N];
int f[N];

int lowbit(int x) {
    return x & -x;
}

void add(int x, int c) {
    for (int i = x; i <= sz; i += lowbit(i)) {
        tr[i] = max(tr[i], c);
    }
}

int query(int x) {
    int ret = -0x3f3f3f3f;
    for (int i = x; i; i -= lowbit(i)) {
        ret = max(ret, tr[i]);
    }
    return ret;
}

int find(LL x) {
    int l = 1, r = sz;
    while (l < r) {
        int mid = l + r >> 1;
        if (xs[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return l;
}

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%lld", s + i);
        s[i] += s[i - 1];
        xs[++sz] = s[i];
    }
    xs[++sz] = 0;
    sort(xs + 1, xs + sz + 1);
    sz = unique(xs + 1, xs + sz + 1) - xs - 1;
    memset(tr, -0x3f, sizeof(tr));  // 需要先初始化成负无穷，因为维护的是s[i]-i，可能是负数
    for (int i = 1; i <= n; i++) {
        add(find(s[i - 1]), f[i - 1] - i + 1);  // 维护前一个结果s[i-1]-(i-1)
        f[i] = max(f[i - 1], query(find(s[i])) + i);
    }
    printf("%d", f[n]);
    
    return 0;
}

　　线段树做法，AC代码如下：

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N = 2e5 + 10, INF = -0x3f3f3f3f;

LL s[N];
LL xs[N], sz;
int f[N];
struct Node {
    int l, r, maxv;
}tr[N * 4];

void build(int u, int l, int r) {
    if (l == r) {
        tr[u] = {l, r, INF};
    }
    else {
        int mid = l + r >> 1;
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        tr[u] = {l, r, INF};
    }
}

void modify(int u, int x, int c) {
    if (tr[u].l == tr[u].r) {
        tr[u].maxv = c;
    }
    else {
        if (x <= tr[u].l + tr[u].r >> 1) modify(u << 1, x, c);
        else modify(u << 1 | 1, x, c);
        tr[u].maxv = max(tr[u << 1].maxv, tr[u << 1 | 1].maxv);
    }
}

int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].maxv;
    int mid = tr[u].l + tr[u].r >> 1, maxv = INF;
    if (l <= mid) maxv = query(u << 1, l, r);
    if (r >= mid + 1) maxv = max(maxv, query(u << 1 | 1, l, r));
    return maxv;
}

int find(LL x) {
    int l = 1, r = sz;
    while (l < r) {
        int mid = l + r >> 1;
        if (xs[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return l;
}

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%lld", s + i);
        s[i] += s[i - 1];
        xs[++sz] = s[i];
    }
    xs[++sz] = 0;
    sort(xs + 1, xs + sz + 1);
    sz = unique(xs + 1, xs + sz + 1) - xs - 1;
    build(1, 1, sz);
    for (int i = 1; i <= n; i++) {
        modify(1, find(s[i - 1]), f[i - 1] - i + 1);
        f[i] = max(f[i - 1], query(1, 1, find(s[i])) + i);
    }
    printf("%d", f[n]);
    
    return 0;
}

 

参考资料

　　Codeforces Round #851 (Div. 2) Editorial：https://codeforces.com/blog/entry/112584