MMSUM - Editorial



Author: Sergey Kulik
Testers: Kevin Atienza and Vasya Antoniuk
Translators: Sergey Kulik (Russian), Team VNOI (Vietnamese) and Hu Zecong (Mandarin)
Editorialist: Kevin Atienza




Maximum Subarray Sum


Given an array A[1\ldots N], what is the maximum subarray sum you can get by removing at most one element?


For every position i, compute the maximum subarray sum that ends in position i. Call it E[i].
For every position i, compute the maximum subarray sum that starts in position i. Call it S[i].

Both can be done in O(N) using Kadane’s algorithm/dynamic programming.

The answer is the largest among the following values:

  • The maximum in E.
  • The maximum E[i-1] + S[i+1] for every position 1 < i < N.


No removals

Let’s first answer a simpler question: What is the maximum subarray sum of the array (without any removals)? This is actually a standard problem and you might already be familiar with it, but let’s describe it anyway.

Here’s a naïve solution (in pseudocode):

answer = -INFINITY
for j=1..N:
    current = 0
    for i=j..1 by -1:
        current += A[i]
        answer = max(answer, current)

It simply tries out all subarrays. Unfortunately, this is slow; it runs in O(N^2) time, and for N \approx 10^5 this will not pass the time limit.

To improve this solution, notice that we don’t have to check all the subarrays that end at j. We can classify all such subarrays into two types: whether it has length 1 or length greater than 1.

  • If it has length 1, then the sum is simply A[j].
  • If it has length greater than 1, then we can break this subarray into two parts. The first part is a subarray that ends in j-1, and the second is A[j] itself. Thus, in order to maximize the sum, we must choose the subarray that ends in j-1 with the maximum sum.

That last part is crucial; if you study the code above more closely, notice that what we’re computing is, for every possible rightmost index j, the maximum subarray sum that ends in j. And we’re doing this in increasing order of j. Thus, when we’re trying to compute it for j, we already have the answer for j-1, so we don’t need a loop any more!

The following code illustrates it better:

answer = -INFINITY
current = 0
for j=1..N:
    current = max(A[j], current + A[j])
    answer = max(answer, current)

Notice that before the line current = max(A[j], current + A[j]), the variable current contains the maximum sum that ends in j-1. Thus, current + A[j] is the maximum sum of any subarray that ends in j with length greater than 1.

This is now much faster: it runs in O(N) time! Also, if you’re curious, this algorithm is actually famous and has a name: Kadane’s algorithm.

Implementation notes:

  • Note that \left|A[i]\right| can reach up to 10^9, so current and answer will exceed the bounds for 32-bit integers. So you should use 64-bit variables (long long in C/C++, long in Java).
  • For INFINITY, you can use a very large number that will exceed all finite numbers under consideration. Since the maximum absolute sum is only 10^5\cdot 10^9 = 10^{14}, an INFINITY value of, say, 10^{18} is good enough for our purposes!

One removal

Now, let’s answer the original problem, where you are allowed to remove at most one element from the array. We already know the answer when you don’t remove any element, so all that remains it to compute the answer if we remove exactly one element. The maximum among these two is the answer. More specifically,

  • Let M_0 be the answer if you don’t remove any element, and
  • Let M_1 be the answer if you remove one element.

Then the answer is \max(M_0, M_1). We already know M_0 from above, so all that remains is computing M_1.

Obviously, we can try removing each element in turn, and computing the maximum subarray sum, and obtaining M_1 as the maximum among all these maximums. But this takes O(N^2) time which is too slow. We will need a better algorithm.

Suppose we remove the element A[i]. Then there are only three possible cases for the maximum subarray sum:

  • The maximum subarray is completely to the left of A[i].
  • The maximum subarray is completely to the right of A[i].
  • The maximum subarray contains A[i-1] and A[i+1].

But here’s an important observation: in the first two cases, the subarrays are actually also subarrays of the original array, which means their sums cannot be more than M_0. And since we’re trying to maximize the answer and we alreaady know that the answer is \ge M_0, we can safely ignore these cases!

So all that remains is computing the maximum sum of any subarray that contains A[i-1] and A[i+1] (ignoring A[i] of course). We can decompose such a subarray into two parts:

  • A subarray that ends in A[i-1], and
  • A subarray that starts at A[i+1].

These two subarrays don’t overlap, so in order to maximize the sum, we want to maximize them individually. But we have already computed all maximum subarray sums that end in every position, from the previous algorithm! So if we just store the partial results that we got, then we can answer the first part quickly!

In more detail, let E[i] be the maximum subarray sum that ends in A[i]. We can compute E[1\ldots N] using the previous algorithm:

answer = -INFINITY
current = 0
for j=1..N:
    current = max(A[j], current + A[j])
    answer = max(answer, current)
    E[j] = current

Similarly, we can define S[i] to be the maximum subarray sum that starts at A[i]. Computing S[1\ldots N] by performing the algorithm in reverse, as in the following:

current = 0
for j=N..1 by -1:
    current = max(A[j], current + A[j])
    answer = max(answer, current)
    S[j] = current

With arrays S[1\ldots N] and E[1\ldots N], we can now compute the maximum sum of any subarray that contains A[i-1] and A[i+1], assuming A[i] is removed: It is simply E[i-1] + S[i+1]!

for i=2..N-1:
    answer = max(answer, E[i-1] + S[i+1])

By combining all these snippets, we now have the answer to the problem!

Time Complexity:





Setter and tester solutions are for the problem Kitchen Timetable (KTTABLE)

I tried the same but the solution given is not working…Is it for the same problem…i doubt…???

Can this problem be solved using divide and conquer?
Tried,but then got WA.

Please Help me with this !
this is the algorithm applied

1)eliminate one element at a time in the array
2) correspondingly find the maximal sub array sum (by the standard algorithm)
3) store it in another array
4)sort this array and print the last(largest) element.

LINK OF MY SOLUTION:-CodeChef: Practical coding for everyone

This algorithm doesn’t work on n=2

1 Like

according to your algorithm
for Test case
1 -2 3 -2 5
output will be 12

This can be done in just 1 loop with O(1) space cost by adapting Kadane’s method, rather than requiring 3 loops and O(n) (additional) space cost as in the solution shown by setter/tester.

which is a simplified version of

We have to modify this logic
for i=2…N-1:
answer = max(answer, E[i-1] + S[i+1])

answer = max(S[i+1],answer);

then it will work for N=2 as well.


@godmar, I too applied the same algorithm and ended up doing it in a single pass.
Link to the solution

It doesn’t seem to give the correct answer.
where am i going wrong?

Alternate solution:
Got AC
Slightly different from editorial.
Keep two arrays dpWithDelete and dpWithoutDelete which keep track of the MaxSum with and without delete.

Please approve.


calculate two array forward and backward which store the current maximum sum till that index .and now for any index calculate backward[i+1]+forward[i-1] for that index .which indicates the maximum sum for that index if that particular index value is not used… and you have to store maximum value in a variable (which indicate if no element of array is remove)…

link to solution:CodeChef: Practical coding for everyone

@vijju123 @admin

DIFFICULTY: Easy, But this question has tag Medium. Plz. look into this.

answer = -INFINITY
current = 0
for j=1..N:
    current = max(A[j], current + A[j])
    answer = max(answer, current)
    E[j] = current

Here E[j] = current is given, I am having doubt why it’s not E[j] = answer as till i answer is the maximum subarray sum

How to solve this if at most K removals are allowed?

There’s a O(nk) algorithm, but I don’t know of any O(n) algorithms for this.
let dp[i][j] denote the maximum sum ending at i with j removals

ll solve(){
    int n,k;
    ll seq[n];
    ll dp[n+1][k+1];
    ll ans=-1e18;
    for(int i=0;i<n;i++){
    for(int i=0;i<=n;i++){
        for(int j=0;j<=k;j++){
    for(int i=1;i<=n;i++){
      //Either this or the previous with 0 removals 
        for(int j=1;j<=k;j++){
//Either this and previous with j removals or
//Remove this and previous with j-1 removals
    return ans;

Sadly It’s not a question so I can’t verify my code.

1 Like

That’s awesome !!. it’s correct. INOI 2011 had the question, Took me two hours to solve.

Because we want to find, maximum sum subarray “including” the A[i-1]/ A[i+1].