# Maximize sum of atmost K elements in array by taking only corner elements | Set 2

Given an array arr[] and an integer K, the task is to find and maximize the sum of atmost K elements in the Array by taking only corner elements.

A corner element is an element from the start of the array or from the end of the array.

Examples:

Input: N = 8, arr[] = {6, -1, 14, -15, 2, 1, 2, -5}, K = 4
Output: 19
Explanation:
Here the optimal choice is to pick three cards from the beginning. After that if we want to pick the next card, our points will decrease. So maximum points is arr + arr + arr = 19.

Input : N = 5, arr[] = {-2, -1, -6, -3, 1}, K = 2
Output : 1
Here optimal choice is to pick last card. So maximum possible points is arr = 1. Any further selection will reduce the value.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach:

To solve the problem mentioned above we will use Recursion. As we can only take a start or end index value hence initialize two variables and take at most K steps and return the maximum sum among all the possible combinations. Update the maximum sum only if it is greater than the previous sum otherwise skip to the next possible combination. The recursive approach has exponential complexity due to its overlapping subproblem and optimal substructure property.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to Maximize sum of atmost ` `// K elements in Array by taking only corner elements ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return maximum points ` `int` `maxPointCount(``int` `arr[], ``int` `K, ``int` `start, ``int` `end, ` `                  ``int` `points, ``int` `max_points) ` `{ ` `    ``if` `(K == 0) { ` `        ``return` `max_points; ` `    ``} ` `    ``// Pick the start index ` `    ``int` `points_start = points + arr[start]; ` ` `  `    ``// Update maximum points if necessary ` `    ``max_points = max(max_points, points_start); ` ` `  `    ``// Pick the end index ` `    ``int` `points_end = points + arr[end]; ` ` `  `    ``// Update maximum points if necessary ` `    ``max_points = max(max_points, points_end); ` ` `  `    ``// Recursive call to get max value ` `    ``return` `max(maxPointCount(arr, K - 1, start + 1, end, ` `                                ``points_start, max_points), ` `               ``maxPointCount(arr, K - 1, start, end - 1,  ` `                                ``points_end, max_points)); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { -2, -1, -6, -3, 1 }; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``int` `K = 2; ` ` `  `    ``int` `points = 0; ` ` `  `    ``int` `max_points = 0; ` ` `  `    ``// beginning index ` `    ``int` `start = 0; ` ` `  `    ``// end index ` `    ``int` `end = N - 1; ` ` `  `    ``cout << maxPointCount(arr, K, start,  ` `                ``end, points, max_points); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to Maximize ` `// sum of atmost K elements in Array  ` `// by taking only corner elements ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Function to return maximum points ` `static` `int` `maxPointCount(``int` `arr[], ``int` `K,  ` `                         ``int` `start, ``int` `end, ` `                         ``int` `points, ``int` `max_points) ` `{ ` `    ``if` `(K == ``0``) ` `    ``{ ` `        ``return` `max_points; ` `    ``} ` `     `  `    ``// Pick the start index ` `    ``int` `points_start = points + arr[start]; ` ` `  `    ``// Update maximum points if necessary ` `    ``max_points = Math.max(max_points, points_start); ` ` `  `    ``// Pick the end index ` `    ``int` `points_end = points + arr[end]; ` ` `  `    ``// Update maximum points if necessary ` `    ``max_points = Math.max(max_points, points_end); ` ` `  `    ``// Recursive call to get max value ` `    ``return` `Math.max(maxPointCount(arr, K - ``1``, ` `                                  ``start + ``1``, end, ` `                                  ``points_start, max_points), ` `                    ``maxPointCount(arr, K - ``1``, ` `                                  ``start, end - ``1``,  ` `                                  ``points_end, max_points)); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `arr[] = { -``2``, -``1``, -``6``, -``3``, ``1` `}; ` `    ``int` `N = arr.length; ` `    ``int` `K = ``2``; ` `    ``int` `points = ``0``; ` `    ``int` `max_points = ``0``; ` ` `  `    ``// Beginning index ` `    ``int` `start = ``0``; ` ` `  `    ``// End index ` `    ``int` `end = N - ``1``; ` ` `  `    ``System.out.print(maxPointCount(arr, K, start, ` `                                   ``end, points,  ` `                                   ``max_points)); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

## C#

 `// C# implementation to Maximize ` `// sum of atmost K elements in Array  ` `// by taking only corner elements ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function to return maximum points ` `static` `int` `maxPointCount(``int` `[]arr, ``int` `K,  ` `                         ``int` `start, ``int` `end, ` `                         ``int` `points, ``int` `max_points) ` `{ ` `    ``if` `(K == 0) ` `    ``{ ` `        ``return` `max_points; ` `    ``} ` `     `  `    ``// Pick the start index ` `    ``int` `points_start = points + arr[start]; ` ` `  `    ``// Update maximum points if necessary ` `    ``max_points = Math.Max(max_points, points_start); ` ` `  `    ``// Pick the end index ` `    ``int` `points_end = points + arr[end]; ` ` `  `    ``// Update maximum points if necessary ` `    ``max_points = Math.Max(max_points, points_end); ` ` `  `    ``// Recursive call to get max value ` `    ``return` `Math.Max(maxPointCount(arr, K - 1, ` `                                  ``start + 1, end, ` `                                  ``points_start, max_points), ` `                    ``maxPointCount(arr, K - 1, ` `                                  ``start, end - 1,  ` `                                  ``points_end, max_points)); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[]arr = { -2, -1, -6, -3, 1 }; ` `    ``int` `N = arr.Length; ` `    ``int` `K = 2; ` `    ``int` `points = 0; ` `    ``int` `max_points = 0; ` ` `  `    ``// Beginning index ` `    ``int` `start = 0; ` ` `  `    ``// End index ` `    ``int` `end = N - 1; ` ` `  `    ``Console.Write(maxPointCount(arr, K, start, ` `                                ``end, points,  ` `                                ``max_points)); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

Output:

```1
```

Efficient Approach:

To optimize the above solution we will implement the sliding window concept.

• Initially the window size is 0 as we don’t pick any element from the array. We take two-variable curr_points and max_points to represents current points and maximum points.
• Consider K elements one by one from the beginning. So in each step we calculate current points and update maximum points if necessary and after including K elements from the array our sliding window size becomes K, which is the maximum possible.
• After that in each step we pick elements from the end and remove the rightmost element from the previously selected window with first K elements. Update curr_points and max_points. At the end, the window contains K cards from the end of the array.
• Finally in each step remove the leftmost card from the previously selected window with K elements from the end. Update the values for curr_points and max_points. In the end the window size will be 0 again.

Let us look at this example to understand it better, arr[] = {-2, -1, -6, -3, 1}, K = 2 Below is the implementation of the above approach:

 `// C++ implementation to Maximize sum  ` `// of atmost K elements in Array by taking  ` `// only corner elements ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return maximum points ` `int` `maxPointCount(``int` `arr[], ``int` `K, ``int` `size) ` `{ ` `    ``// Initialization of current points  ` `    ``// and max points so far ` `    ``int` `curr_points = 0; ` `    ``int` `max_points = 0; ` ` `  `    ``// Add elements from the beginning ` `    ``for` `(``int` `i = 0; i < K; i++) { ` `        ``curr_points += arr[i]; ` `        ``max_points = max(curr_points, max_points); ` `    ``} ` ` `  `    ``// Points to the end of array element ` `    ``int` `j = size - 1; ` ` `  `    ``// Add K elements from end of array ` `    ``for` `(``int` `i = K - 1; i >= 0; i--) { ` `        ``curr_points = curr_points + arr[j] - arr[i]; ` `        ``max_points = max(curr_points, max_points); ` ` `  `        ``// Decrement the value for j ` `        ``j--; ` `    ``} ` ` `  `    ``j = size - K; ` ` `  `    ``for` `(; j < size; j++) { ` `        ``curr_points = curr_points - arr[j]; ` `        ``max_points = max(curr_points, max_points); ` `    ``} ` ` `  `    ``// Return the final result ` `    ``return` `max_points; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { -2, -1, -6, -3, 1 }; ` ` `  `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``int` `K = 2; ` ` `  `    ``cout << maxPointCount(arr, K, N); ` ` `  `    ``return` `0; ` `} `

Output:

```1
```

Time Complexity: O(n)

Auxiliary Space: O(1)

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.