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

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[0], arr[1]) and (arr[5], arr[6]).
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[0]);` `    ``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 code 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[0] >= pq[0]) ``            ``break``; ` `          ``// Remove the minimum of ``          ``// the taken elements ``          ``curans -= pq2[0]; ``          ``pq2.RemoveAt(0); ` `          ``// Add maximum of the ``          ``// discarded elements ``          ``curans += pq[0]; ``          ``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)

Previous
Next