PROBLEM LINK:Author: Sergey Kulik DIFFICULTY: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]$. Both can be done in $O(N)$ using Kadane's algorithm/dynamic programming. The answer is the largest among the following values:
EXPLANATION:No removalsLet'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):
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$.
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 $j1$, so we don't need a loop any more! The following code illustrates it better:
Notice that before the line 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:
One removalNow, 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,
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:
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[i1]$ and $A[i+1]$ (ignoring $A[i]$ of course). We can decompose such a subarray into two parts:
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:
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:
With arrays $S[1\ldots N]$ and $E[1\ldots N]$, we can now compute the maximum sum of any subarray that contains $A[i1]$ and $A[i+1]$, assuming $A[i]$ is removed: It is simply $E[i1] + S[i+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".
asked 27 May '16, 07:32

Setter and tester solutions are for the problem Kitchen Timetable (KTTABLE) answered 31 May '16, 22:01

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

Can this problem be solved using divide and conquer? answered 31 May '16, 22:40

Please Help me with this ! this is the algorithm applied 1)eliminate one element at a time in the array LINK OF MY SOLUTION:https://www.codechef.com/viewsolution/10256324 answered 01 Jun '16, 01:05

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

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

We have to modify this logic for i=2..N1: answer = max(answer, E[i1] + S[i+1]) As for(i=1;i<=N;i++{ if(i1<1){ answer = max(S[i+1],answer); }else{ if(i+1==N+1){ answer=max(answer,E[i1]); }else{ answer=max(answer,E[i1]+S[i+1]; } } then it will work for N=2 as well. } answered 01 Jun '16, 09:47

@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

https://www.codechef.com/viewsolution/10260527 where am i going wrong? answered 01 Jun '16, 13:55

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

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[i1] 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

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
