# Maximize sum of K pairs made up of elements that are equidistant from both ends of the array

• Last Updated : 19 Jul, 2021

Given an array arr[] consisting of N integers and an integer K, the task is to find the maximum sum of K pairs of the form (arr[i], arr[N – i – 1]), where (0 â‰¤ i â‰¤ N – 1).

Examples:

Input: arr[] = {2, -4, 3, -1, 2, 5}, K = 2
Output: 9
Explanation: All possibles pair of the form (arr[i], arr[N – i + 1]) are:

1. (2, 5)
2. (-1, 3)
3. (-4, 2)

From the above pairs, the K(= 2) pairs with maximum sum are (2, 5) and (-1, 3). Therefore, maximum sum = 2 + 5 + (-1) + 3 = 9.

Input: arr[] = {2, -4, -2, 4}, K = 2
Output: 0

Naive Approach: The simplest approach to solve the problem is to generate all possible pairs of the given form from the array and calculate the maximum sum of K such pairs. After checking for all the pairs, print the maximum sum obtained among all the possible sums.

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

Efficient Approach: The above approach can be optimized greedily. The idea is to choose only the K pairs with highest cost. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the maximum sum of``// K pairs of the form (arr[i],``// arr[N - i - 1])``int` `maxSum(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Stores the resultant pairwise``    ``// sum``    ``vector<``int``> pairwiseSum;` `    ``// Traverse till half of the array``    ``for` `(``int` `i = 0; i < N / 2; i++) {` `        ``// Update the value of curSum``        ``int` `curSum = arr[i] + arr[i + N / 2];``        ``pairwiseSum.push_back(curSum);``    ``}` `    ``// Sort in the descending order``    ``sort(pairwiseSum.begin(),``         ``pairwiseSum.end(),``         ``greater<``int``>());` `    ``// Stores the resultant maximum sum``    ``int` `maxSum = 0;` `    ``// Add K maximum sums obtained``    ``for` `(``int` `i = 0; i < K; i++) {` `        ``// Update the value of maxSum``        ``maxSum += pairwiseSum[i];``    ``}` `    ``// Print the maximum sum``    ``cout << maxSum;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, -4, 3, 5, 2, -1 };``    ``int` `K = 2;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``maxSum(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.ArrayList;``import` `java.util.Collections;``class` `GFG{` `// Function to find the maximum sum of``// K pairs of the form (arr[i],``// arr[N - i - 1])``public` `static` `void` `maxSum(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Stores the resultant pairwise``    ``// sum``    ``ArrayList pairwiseSum = ``new` `ArrayList();` `    ``// Traverse till half of the array``    ``for` `(``int` `i = ``0``; i < N / ``2``; i++) {` `        ``// Update the value of curSum``        ``int` `curSum = arr[i] + arr[i + N / ``2``];``        ``pairwiseSum.add(curSum);``    ``}` `    ``// Sort in the descending order``    ``Collections.sort(pairwiseSum);``    ``Collections.reverse(pairwiseSum);` `    ``// Stores the resultant maximum sum``    ``int` `maxSum = ``0``;` `    ``// Add K maximum sums obtained``    ``for` `(``int` `i = ``0``; i < K; i++) {` `        ``// Update the value of maxSum``        ``maxSum += pairwiseSum.get(i);``    ``}` `    ``// Print the maximum sum``    ``System.out.println(maxSum);``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `arr[] = { ``2``, -``4``, ``3``, ``5``, ``2``, -``1` `};``    ``int` `K = ``2``;``    ``int` `N = arr.length;``    ``maxSum(arr, N, K);``}``}` `// This code is contributed by gfgking.`

## Python3

 `# Python3 program for the above approach` `# Function to find the maximum sum of``# K pairs of the form (arr[i],``# arr[N - i - 1])``def` `maxSum(arr, N, K):``    ` `    ``# Stores the resultant pairwise``    ``# sum``    ``pairwiseSum ``=` `[]` `    ``# Traverse till half of the array``    ``for` `i ``in` `range``(N ``/``/` `2``):``        ` `        ``# Update the value of curSum``        ``curSum ``=` `arr[i] ``+` `arr[i ``+` `N ``/``/` `2``]``        ``pairwiseSum.append(curSum)` `    ``# Sort in the descending order``    ``pairwiseSum.sort(reverse ``=` `True``)` `    ``# Stores the resultant maximum sum``    ``maxSum ``=` `0` `    ``# Add K maximum sums obtained``    ``for` `i ``in` `range``(K):``        ` `        ``# Update the value of maxSum``        ``maxSum ``+``=` `pairwiseSum[i]` `    ``# Print the maximum sum``    ``print``(maxSum)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``2``, ``-``4``, ``3``, ``5``, ``2``, ``-``1` `]``    ``K ``=` `2``    ``N ``=` `len``(arr)``    ` `    ``maxSum(arr, N, K)` `# This code is contributed by bgangwar59`

## C#

 `// C# program for the above approach` `using` `System;``using` `System.Collections.Generic;` `class` `GFG{`` ` `// Function to find the maximum sum of``// K pairs of the form (arr[i],``// arr[N - i - 1])``static` `void` `maxSum(``int` `[]arr, ``int` `N, ``int` `K)``{``    ``// Stores the resultant pairwise``    ``// sum``    ``List<``int``> pairwiseSum = ``new` `List<``int``>();` `    ``// Traverse till half of the array``    ``for` `(``int` `i = 0; i < N / 2; i++) {` `        ``// Update the value of curSum``        ``int` `curSum = arr[i] + arr[i + N / 2];``        ``pairwiseSum.Add(curSum);``    ``}` `    ``// Sort in the descending order``    ``pairwiseSum.Sort();``    ``pairwiseSum.Reverse();``    ``// Stores the resultant maximum sum``    ``int` `maxSum = 0;` `    ``// Add K maximum sums obtained``    ``for` `(``int` `i = 0; i < K; i++) {` `        ``// Update the value of maxSum``        ``maxSum += pairwiseSum[i];``    ``}` `    ``// Print the maximum sum``    ``Console.Write(maxSum);``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `[]arr = { 2, -4, 3, 5, 2, -1 };``    ``int` `K = 2;``    ``int` `N = arr.Length;``    ``maxSum(arr, N, K);` `}``}` `// This code is contributed by ipg2016107.`

## Javascript

 ``

Output:

`9`

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

My Personal Notes arrow_drop_up