×

# 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

Easy

# PREREQUISITES:

Maximum Subarray Sum

# PROBLEM:

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

# QUICK EXPLANATION:

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]


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])


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])
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])
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:


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

# Time Complexity:

$O(N)$

# AUTHOR'S AND TESTER'S SOLUTIONS:

This question is marked "community wiki".

1.7k586142
accept rate: 11%

19.8k350498541

 1 This algorithm doesn't work on n=2 answered 01 Jun '16, 04:27 2★cc15 11●2 accept rate: 0%
 0 Setter and tester solutions are for the problem Kitchen Timetable (KTTABLE) answered 31 May '16, 22:01 33●4 accept rate: 0%
 0 I tried the same but the solution given is not working.......Is it for the same problem.....i doubt....??????? answered 31 May '16, 22:21 1 accept rate: 0%
 0 Can this problem be solved using divide and conquer? Tried,but then got WA. answered 31 May '16, 22:40 206●1●2●9 accept rate: 9%
 0 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:-https://www.codechef.com/viewsolution/10256324 answered 01 Jun '16, 01:05 103●6 accept rate: 5%
 0 according to your algorithm for Test case n=5 input 1 -2 3 -2 5 output will be 12 answered 01 Jun '16, 07:42 1 accept rate: 0%
 0 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. Example https://www.codechef.com/viewsolution/10259181 which is a simplified version of https://www.codechef.com/viewsolution/10214880 answered 01 Jun '16, 09:32 2★godmar 1 accept rate: 0%
 0 @godmar, I too applied the same algorithm and ended up doing it in a single pass. Link to the solution answered 01 Jun '16, 12:01 3★vjvishjn 31●2 accept rate: 0%
 0 It doesn't seem to give the correct answer. answered 01 Jun '16, 12:02 1 accept rate: 0%
 0 https://www.codechef.com/viewsolution/10260527 where am i going wrong? answered 01 Jun '16, 13:55 19●1 accept rate: 0%
 0 Alternate solution: Got AC Slightly different from editorial. Keep two arrays dpWithDelete and dpWithoutDelete which keep track of the MaxSum with and without delete. Link https://www.codechef.com/viewsolution/10193855 Please approve. answered 01 Jun '16, 14:16 1 accept rate: 0%
 0 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:https://www.codechef.com/viewsolution/15065218 answered 21 Aug '17, 19:37 1●1 accept rate: 0%
 0 DIFFICULTY: Easy, But this question has tag Medium. Plz. look into this. answered 01 Mar '18, 03:20 2.7k●1●6●18 accept rate: 10%
 0 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 answered 13 Mar, 19:41 1 accept rate: 0%
 toggle preview community wiki:
Preview

By Email:

Markdown Basics

• *italic* or _italic_
• **bold** or __bold__
• image?![alt text](/path/img.jpg "title")
• numbered list: 1. Foo 2. Bar
• to add a line break simply add two spaces to where you would like the new line to be.
• basic HTML tags are also supported
• mathemetical formulas in Latex between \$ symbol

Question tags:

×15,875
×2,658
×55
×20

question asked: 27 May '16, 07:32

question was seen: 10,786 times

last updated: 13 Mar, 19:41