# Maximum subarray sum possible after removing at most K array elements

• Difficulty Level : Hard
• Last Updated : 17 Jul, 2021

Given an array arr[] of size N and an integer K, the task is to find the maximum subarray sum by removing at most K elements from the array.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = { -2, 1, 3, -2, 4, -7, 20 }, K = 1
Output: 26
Explanation:
Removing arr[5] from the array modifies arr[] to { -2, 1, 3, -2, 4, 20 }
Subarray with maximum sum is { 1, 3, -2, 4, 20 }.
Therefore, the required output is 26.

Input:arr[] = { -1, 1, -1, -1, 1, 1 }, K=2
Output:
Explanation:
Removing arr[2] and arr[3] from the array modifies arr[] to { – 1, 1, 1, 1}
Subarray with maximum sum is { 1, 1, 1 }.
Therefore, the required output is 3.

Approach: The problem can be solved using Dynamic Programming. The idea is to use the concept of Kadane’s algorithm. Follow the steps below to solve the problem:

• Traverse the array arr[] and for every array element following two operations needs to be performed:
• Remove the current array element from the subarray.
• Include the current array element in the subarray.
• Therefore, the recurrence relation to solve this problem is as follows:

mxSubSum(i, j) = max(max(0, arr[i] + mxSubSum(i – 1, j)), mxSubSum(i – 1, j – 1))

i: Stores index of array element
j: Maximum count of elements that can be removed from the subarray
mxSubSum(i, j): Return maximum subarray sum from the subarray { arr[i], arr[N – 1] } by removing K – j array elements.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;` `#define M 100`   `// Function to find the maximum subarray` `// sum greater than or equal to 0 by` `// removing K array elements` `int` `mxSubSum(``int` `i, ``int``* arr,` `             ``int` `j, ``int` `dp[][M])` `{` `    ``// Base case` `    ``if` `(i == 0) {` `        ``return` `dp[i][j] = max(0, arr[i]);` `    ``}`   `    ``// If overlapping subproblems` `    ``// already occurred` `    ``if` `(dp[i][j] != -1) {` `        ``return` `dp[i][j];` `    ``}`   `    ``// Include current element in the subarray` `    ``int` `X = max(0, arr[i]` `                       ``+ mxSubSum(i - 1, arr, j, dp));`   `    ``// If K elements already removed` `    ``// from the subarray` `    ``if` `(j == 0) {`   `        ``return` `dp[i][j] = X;` `    ``}`   `    ``// Remove current element from the subarray` `    ``int` `Y = mxSubSum(i - 1, arr, j - 1, dp);`   `    ``return` `dp[i][j] = max(X, Y);` `}`   `// Utility function to find the maximum subarray` `// sum by removing at most K array elements` `int` `MaximumSubarraySum(``int` `n, ``int``* arr, ``int` `k)` `{`   `    ``// Stores overlapping subproblems` `    ``// of the recurrence relation` `    ``int` `dp[M][M];`   `    ``// Initialize dp[][] to -1` `    ``memset``(dp, -1, ``sizeof``(dp));`   `    ``mxSubSum(n - 1, arr, k, dp);`   `    ``// Stores maximum subarray sum by` `    ``// removing at most K elements` `    ``int` `res = 0;`   `    ``// Calculate maximum element` `    ``// in dp[][]` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = 0; j <= k; j++) {`   `            ``// Update res` `            ``res = max(res, dp[i][j]);` `        ``}` `    ``}`   `    ``// If all array elements are negative` `    ``if` `(*max_element(arr, arr + n) < 0) {`   `        ``// Update res` `        ``res = *max_element(arr, arr + n);` `    ``}` `    ``return` `res;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { -2, 1, 3, -2, 4, -7, 20 };` `    ``int` `K = 1;` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << MaximumSubarraySum(N, arr, K) << endl;`   `    ``return` `0;` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;`   `class` `GFG{` `static` `final` `int` `M = ``100``;`   `// Function to find the maximum subarray` `// sum greater than or equal to 0 by` `// removing K array elements` `static` `int` `mxSubSum(``int` `i, ``int` `[]arr,` `             ``int` `j, ``int` `dp[][])` `{` `    ``// Base case` `    ``if` `(i == ``0``) {` `        ``return` `dp[i][j] = Math.max(``0``, arr[i]);` `    ``}`   `    ``// If overlapping subproblems` `    ``// already occurred` `    ``if` `(dp[i][j] != -``1``) {` `        ``return` `dp[i][j];` `    ``}`   `    ``// Include current element in the subarray` `    ``int` `X = Math.max(``0``, arr[i]` `                       ``+ mxSubSum(i - ``1``, arr, j, dp));`   `    ``// If K elements already removed` `    ``// from the subarray` `    ``if` `(j == ``0``) ` `    ``{` `        ``return` `dp[i][j] = X;` `    ``}`   `    ``// Remove current element from the subarray` `    ``int` `Y = mxSubSum(i - ``1``, arr, j - ``1``, dp);`   `    ``return` `dp[i][j] = Math.max(X, Y);` `}`   `// Utility function to find the maximum subarray` `// sum by removing at most K array elements` `static` `int` `MaximumSubarraySum(``int` `n, ``int` `[]arr, ``int` `k)` `{`   `    ``// Stores overlapping subproblems` `    ``// of the recurrence relation` `    ``int` `[][]dp = ``new` `int``[M][M];`   `    ``// Initialize dp[][] to -1` `    ``for` `(``int` `i = ``0``; i < M; i++)` `        ``for` `(``int` `j = ``0``; j < M; j++)` `            ``dp[i][j] = -``1``;`   `    ``mxSubSum(n - ``1``, arr, k, dp);`   `    ``// Stores maximum subarray sum by` `    ``// removing at most K elements` `    ``int` `res = ``0``;`   `    ``// Calculate maximum element` `    ``// in dp[][]` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `        ``for` `(``int` `j = ``0``; j <= k; j++) {`   `            ``// Update res` `            ``res = Math.max(res, dp[i][j]);` `        ``}` `    ``}`   `    ``// If all array elements are negative` `    ``if` `(Arrays.stream(arr).max().getAsInt() < ``0``) {`   `        ``// Update res` `        ``res = Arrays.stream(arr).max().getAsInt();` `    ``}` `    ``return` `res;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { -``2``, ``1``, ``3``, -``2``, ``4``, -``7``, ``20` `};` `    ``int` `K = ``1``;` `    ``int` `N = arr.length;` `    ``System.out.print(MaximumSubarraySum(N, arr, K) +``"\n"``);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to implement` `# the above approach` `M ``=` `100`   `# Function to find the maximum subarray` `# sum greater than or equal to 0 by` `# removing K array elements` `def` `mxSubSum(i, arr, j):` `    ``global` `dp` `    `  `    ``# Base case` `    ``if` `(i ``=``=` `0``):` `        ``dp[i][j] ``=` `max``(``0``, arr[i])` `        ``return` `dp[i][j]`   `    ``# If overlapping subproblems` `    ``# already occurred` `    ``if` `(dp[i][j] !``=` `-``1``):` `        ``return` `dp[i][j]`   `    ``# Include current element in the subarray` `    ``X ``=` `max``(``0``, arr[i] ``+` `mxSubSum(i ``-` `1``, arr, j))`   `    ``# If K elements already removed` `    ``# from the subarray` `    ``if` `(j ``=``=` `0``):`   `        ``dp[i][j] ``=` `X` `        ``return` `X`   `    ``# Remove current element from the subarray` `    ``Y ``=` `mxSubSum(i ``-` `1``, arr, j ``-` `1``)`   `    ``dp[i][j] ``=` `max``(X, Y)`   `    ``return` `dp[i][j]`   `# Utility function to find the maximum subarray` `# sum by removing at most K array elements` `# Utility function to find the maximum subarray` `# sum by removing at most K array elements` `def` `MaximumSubarraySum(n, arr, k):`   `    ``mxSubSum(n ``-` `1``, arr, k)`   `    ``# Stores maximum subarray sum by` `    ``# removing at most K elements` `    ``res ``=` `0`   `    ``# Calculate maximum element` `    ``# in dp[][]` `    ``for` `i ``in` `range``(n):` `        ``for` `j ``in` `range``(k ``+` `1``):`   `            ``# Update res` `            ``res ``=` `max``(res, dp[i][j])`   `    ``# If all array elements are negative` `    ``if` `(``max``(arr) < ``0``):`   `        ``# Update res` `        ``res ``=` `max``(arr)` `    ``return` `res`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``dp ``=` `[[``-``1` `for` `i ``in` `range``(``100``)] ``for` `i ``in` `range``(``100``)]` `    ``arr ``=` `[``-``2``, ``1``, ``3``, ``-``2``, ``4``, ``-``7``, ``20``]` `    ``K ``=` `1` `    ``N ``=` `len``(arr)` `    ``print``(MaximumSubarraySum(N, arr, K))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections;`   `class` `GFG{` `    `  `static` `int` `M = 100;`   `// Function to find the maximum subarray` `// sum greater than or equal to 0 by` `// removing K array elements` `static` `int` `mxSubSum(``int` `i, ``int` `[]arr,` `                    ``int` `j, ``int` `[,]dp)` `{` `    `  `    ``// Base case` `    ``if` `(i == 0)` `    ``{` `        ``return` `dp[i, j] = Math.Max(0, arr[i]);` `    ``}`   `    ``// If overlapping subproblems` `    ``// already occurred` `    ``if` `(dp[i, j] != -1) ` `    ``{` `        ``return` `dp[i, j];` `    ``}`   `    ``// Include current element in the subarray` `    ``int` `X = Math.Max(0, arr[i] + ` `                    ``mxSubSum(i - 1, arr, j, dp));`   `    ``// If K elements already removed` `    ``// from the subarray` `    ``if` `(j == 0) ` `    ``{` `        ``return` `dp[i, j] = X;` `    ``}`   `    ``// Remove current element from the subarray` `    ``int` `Y = mxSubSum(i - 1, arr, j - 1, dp);`   `    ``return` `dp[i, j] = Math.Max(X, Y);` `}`   `// Utility function to find the maximum subarray` `// sum by removing at most K array elements` `static` `int` `MaximumSubarraySum(``int` `n, ``int` `[]arr, ``int` `k)` `{` `    `  `    ``// Stores overlapping subproblems` `    ``// of the recurrence relation` `    ``int` `[,]dp = ``new` `int``[M, M];`   `    ``// Initialize dp[,] to -1` `    ``for``(``int` `i = 0; i < M; i++)` `        ``for``(``int` `j = 0; j < M; j++)` `            ``dp[i, j] = -1;`   `    ``mxSubSum(n - 1, arr, k, dp);`   `    ``// Stores maximum subarray sum by` `    ``// removing at most K elements` `    ``int` `res = 0;`   `    ``// Calculate maximum element` `    ``// in dp[,]` `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        ``for``(``int` `j = 0; j <= k; j++) ` `        ``{` `            `  `            ``// Update res` `            ``res = Math.Max(res, dp[i, j]);` `        ``}` `    ``}`   `    ``Array.Sort(arr);` `    `  `    ``// If all array elements are negative` `    `  `    ``if` `(arr[n - 1] < 0)` `    ``{` `        `  `        ``// Update res` `        ``res = arr[n - 1];` `    ``}` `    ``return` `res;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[]arr = { -2, 1, 3, -2, 4, -7, 20 };` `    ``int` `K = 1;` `    ``int` `N = arr.Length;` `    `  `    ``Console.WriteLine(MaximumSubarraySum(N, arr, K));` `}` `}`   `// This code is contributed by AnkThon`

## Javascript

 ``

Output:

`26`

Time Complexity: O(N * K)
Auxiliary Space: O(N * K)

My Personal Notes arrow_drop_up
Recommended Articles
Page :