# Maximum possible sub-array sum after at most X swaps

• Difficulty Level : Medium
• Last Updated : 30 May, 2022

Given an array arr[] of N integers and an integer X, the task is to find the maximum possible sub-array sum after applying at most X swaps.
Examples:

Input: arr[] = {5, -1, 2, 3, 4, -2, 5}, X = 2
Output: 19
Swap (arr, arr) and (arr, arr).
Now, the maximum sub-array sum will be (5 + 2 + 3 + 4 + 5) = 19
Input: arr[] = {-2, -3, -1, -10}, X = 10
Output: -1

Approach: For every possible sub-array, consider the elements which are not part of this sub-array as discarded. Now, while there are swaps left and the sum of the sub-array currently under consideration can be maximized i.e. the greatest element among the discarded elements can be swapped with the minimum element of the sub-array, keep updating the sum of the sub-array. When there are no swaps left or the sub-array sum cannot be further maximized, update the current maximum sub-array sum found so far which will be the required answer in the end.
Below is the implementation of the above approach:

## CPP

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the maximum``// sub-array sum after at most x swaps``int` `SubarraySum(``int` `a[], ``int` `n, ``int` `x)``{``    ``// To store the required answer``    ``int` `ans = -10000;` `    ``// For all possible intervals``    ``for` `(``int` `i = 0; i < n; i++) {``        ``for` `(``int` `j = i; j < n; j++) {` `            ``// Keep current ans as zero``            ``int` `curans = 0;` `            ``// To store the integers which are``            ``// not part of the sub-array``            ``// currently under consideration``            ``priority_queue<``int``, vector<``int``> > pq;` `            ``// To store elements which are``            ``// part of the sub-array``            ``// currently under consideration``            ``priority_queue<``int``, vector<``int``>, greater<``int``> > pq2;` `            ``// Create two sets``            ``for` `(``int` `k = 0; k < n; k++) {``                ``if` `(k >= i && k <= j) {``                    ``curans += a[k];``                    ``pq2.push(a[k]);``                ``}``                ``else``                    ``pq.push(a[k]);``            ``}``            ``ans = max(ans, curans);` `            ``// Swap at most X elements``            ``for` `(``int` `k = 1; k <= x; k++) {``                ``if` `(pq.empty() || pq2.empty()``                    ``|| pq2.top() >= pq.top())``                    ``break``;` `                ``// Remove the minimum of``                ``// the taken elements``                ``curans -= pq2.top();``                ``pq2.pop();` `                ``// Add maximum of the``                ``// discarded elements``                ``curans += pq.top();``                ``pq.pop();` `                ``// Update the answer``                ``ans = max(ans, curans);``            ``}``        ``}``    ``}` `    ``// Return the maximized sub-array sum``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``int` `a[] = { 5, -1, 2, 3, 4, -2, 5 }, x = 2;``    ``int` `n = ``sizeof``(a) / ``sizeof``(a);` `    ``cout << SubarraySum(a, n, x);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.io.*;``import` `java.util.*;``class` `GFG``{` `  ``// Function to return the maximum``  ``// sub-array sum after at most x swaps``  ``static` `int` `SubarraySum(``int``[] a, ``int` `n, ``int` `x)``  ``{` `    ``// To store the required answer``    ``int` `ans = -``10000``;` `    ``// For all possible intervals``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``      ``for` `(``int` `j = i; j < n; j++)``      ``{` `        ``// Keep current ans as zero``        ``int` `curans = ``0``;` `        ``// To store the integers which are``        ``// not part of the sub-array``        ``// currently under consideration``        ``ArrayList pq = ``new` `ArrayList();` `        ``// To store elements which are``        ``// part of the sub-array``        ``// currently under consideration``        ``ArrayList pq2 = ``new` `ArrayList();` `        ``// Create two sets``        ``for` `(``int` `k = ``0``; k < n; k++) {``          ``if` `(k >= i && k <= j) {``            ``curans += a[k];``            ``pq2.add(a[k]);``          ``}``          ``else``            ``pq.add(a[k]);``        ``}` `        ``Collections.sort(pq);``        ``Collections.reverse(pq);``        ``Collections.sort(pq2);` `        ``ans = Math.max(ans, curans);` `        ``// Swap at most X elements``        ``for` `(``int` `k = ``1``; k <= x; k++) {``          ``if` `(pq.size() == ``0` `|| pq2.size() == ``0``              ``|| pq2.get(``0``) >= pq.get(``0``))``            ``break``;` `          ``// Remove the minimum of``          ``// the taken elements``          ``curans -= pq2.get(``0``);``          ``pq2.remove(``0``);` `          ``// Add maximum of the``          ``// discarded elements``          ``curans += pq.get(``0``);``          ``pq.remove(``0``);` `          ``// Update the answer``          ``ans = Math.max(ans, curans);``        ``}``      ``}``    ``}` `    ``// Return the maximized sub-array sum``    ``return` `ans;``  ``}` `  ``// Driver code.``  ``public` `static` `void` `main (String[] args)``  ``{` `    ``int``[] a = { ``5``, -``1``, ``2``, ``3``, ``4``, -``2``, ``5` `};``    ``int` `x = ``2``;``    ``int` `n = a.length;` `    ``System.out.println(SubarraySum(a, n, x));``  ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 implementation of the approach` `# Function to return the maximum``# sub-array sum after at most x swaps``def` `SubarraySum(a, n, x) :``    ` `    ``# To store the required answer``    ``ans ``=` `-``10000``    ` `    ``# For all possible intervals``    ``for` `i ``in` `range``(n) :``    ` `      ``for` `j ``in` `range``(i, n) :``    ` `        ``# Keep current ans as zero``        ``curans ``=` `0``    ` `        ``# To store the integers which are``        ``# not part of the sub-array``        ``# currently under consideration``        ``pq ``=` `[]``    ` `        ``# To store elements which are``        ``# part of the sub-array``        ``# currently under consideration``        ``pq2 ``=` `[]``    ` `        ``# Create two sets``        ``for` `k ``in` `range``(n) :``          ``if` `(k >``=` `i ``and` `k <``=` `j) :``            ``curans ``+``=` `a[k]``            ``pq2.append(a[k])``          ` `          ``else` `:``            ``pq.append(a[k])``    ` `        ``pq.sort()``        ``pq.reverse()``        ``pq2.sort()``    ` `        ``ans ``=` `max``(ans, curans)``    ` `        ``# Swap at most X elements``        ``for` `k ``in` `range``(``1``, x ``+` `1``) :``          ``if` `(``len``(pq) ``=``=` `0` `or` `len``(pq2) ``=``=` `0` `or` `pq2[``0``] >``=` `pq[``0``]) :``            ``break``    ` `          ``# Remove the minimum of``          ``# the taken elements``          ``curans ``-``=` `pq2[``0``]``          ``pq2.pop(``0``)``    ` `          ``# Add maximum of the``          ``# discarded elements``          ``curans ``+``=` `pq[``0``]``          ``pq.pop(``0``)``    ` `          ``# Update the answer``          ``ans ``=` `max``(ans, curans)``    ` `    ``# Return the maximized sub-array sum``    ``return` `ans``    ` `    ``# Driver code``a ``=` `[ ``5``, ``-``1``, ``2``, ``3``, ``4``, ``-``2``, ``5` `]``x ``=` `2``;``n ``=` `len``(a)``print``(SubarraySum(a, n, x))` `# This ccode is contributed by divyesh072019.`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `  ``// Function to return the maximum``  ``// sub-array sum after at most x swaps``  ``static` `int` `SubarraySum(``int``[] a, ``int` `n, ``int` `x)``  ``{` `    ``// To store the required answer``    ``int` `ans = -10000;` `    ``// For all possible intervals``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``      ``for` `(``int` `j = i; j < n; j++)``      ``{` `        ``// Keep current ans as zero``        ``int` `curans = 0;` `        ``// To store the integers which are``        ``// not part of the sub-array``        ``// currently under consideration``        ``List<``int``> pq = ``new` `List<``int``>();` `        ``// To store elements which are``        ``// part of the sub-array``        ``// currently under consideration``        ``List<``int``> pq2 = ``new` `List<``int``>();` `        ``// Create two sets``        ``for` `(``int` `k = 0; k < n; k++) {``          ``if` `(k >= i && k <= j) {``            ``curans += a[k];``            ``pq2.Add(a[k]);``          ``}``          ``else``            ``pq.Add(a[k]);``        ``}` `        ``pq.Sort();``        ``pq.Reverse();``        ``pq2.Sort();` `        ``ans = Math.Max(ans, curans);` `        ``// Swap at most X elements``        ``for` `(``int` `k = 1; k <= x; k++) {``          ``if` `(pq.Count == 0 || pq2.Count == 0``              ``|| pq2 >= pq)``            ``break``;` `          ``// Remove the minimum of``          ``// the taken elements``          ``curans -= pq2;``          ``pq2.RemoveAt(0);` `          ``// Add maximum of the``          ``// discarded elements``          ``curans += pq;``          ``pq.RemoveAt(0);` `          ``// Update the answer``          ``ans = Math.Max(ans, curans);``        ``}``      ``}``    ``}` `    ``// Return the maximized sub-array sum``    ``return` `ans;``  ``}` `  ``// Driver code.``  ``static` `void` `Main() {``    ``int``[] a = { 5, -1, 2, 3, 4, -2, 5 };``    ``int` `x = 2;``    ``int` `n = a.Length;``    ``Console.WriteLine(SubarraySum(a, n, x));``  ``}``}` `// This code is contributed by divyeshrabaiya07.`

## Javascript

 ``

Output:

`19`

Time Complexity: O(n3 logn)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up