# Maximize Array sum by choosing pairs and dividing one part and multiplying other by K

• Last Updated : 24 Jan, 2022

Given an array arr[] of size N and integer K, the task is to maximize the sum of the array by performing the following operations any number of times(possibly zero):

• Choose two indices, i and j where arr[i] must be a multiple of K.
• Make arr[i] = arr[i]/K and arr[j] = K*arr[j]
• After performing the above operations, the sum of the elements of the array must be maximum.

Examples:

Input: arr[] = {6, 6, 3}, N = 3, K = 3
Output: 57
Explanation:  The optimal sequence for which sum of the array elements would be maximized is:

• Take i = 0 and j = 1, arr = arr/3 = 2, arr = arr*3 = 18, now the new array becomes, [2, 18, 3]
• Take i = 2 and j = 1, arr = arr/3 = 1, arr = arr*3 = 54, the array becomes [2, 54, 1]

Sum = 2 + 54 + 1 = 57

Input: arr[] = {1, 2, 3, 4, 5}, N = 5, K = 2
Output: 46
Explanation: The operation performed is:
Take i = 1 and j = 4, arr = arr/2 = 1, arr = arr*2 = 10. Now arr[] = {1, 1, 3, 4, 10}.
Take i = 3 and j = 4, arr = arr/2 = 2, arr = arr*2 = 20. Now arr[] = {1, 1, 3, 2, 20}.
Take i = 3 and j = 4, arr = arr/2 = 1, arr = arr*2 = 40. Now arr[] = {1, 1, 3, 1, 40}
Sum = 1 + 1+ 3 + 1 + 40 = 46.

Approach: The greedy approach is to divide all the array elements which are multiples of K by K and count the total number of division operations(say X) performed. Then sort the array and multiply the maximum element of the array X times by K i.e. arr[N-1] = arr[N-1]*KX. Follow the steps below to solve this problem:

• Create a variable total_division = 0, to store a total number of divisions performed.
• Iterate over the range [0, N) using the variable index and perform the following tasks:
• If arr[index] %K = 0, then find out how many times can arr[index] be divided by K and increment total_division that many times.
• Sort the array arr[].
• Run a while loop till total_division > 0 and make arr[N-1] = arr[N-1] * K and decrement total_division.
• Create a variable maximum_sum = 0.
• Iterate over the range [0, N) using the variable index and perform the following tasks:
• Update maximum_sum += arr[index].
• After performing the above steps, print the value of maximum_sum as the answer.

Below is the implementation for the above approach.

## C++

 `// C++ code for the above approach``#include ``using` `namespace` `std;` `// Utility function``int` `MaximumSumOperations(``int` `arr[], ``int` `N,``                         ``int` `K)``{``    ``if` `(N == 1) {``        ``return` `arr;``    ``}` `    ``// Variable to count total operations``    ``int` `total_division = 0;` `    ``// Perform the division operation on``    ``// the elements multiple of K``    ``for` `(``int` `index = 0; index < N;``         ``index++) {``        ``if` `(arr[index] % K == 0) {``            ``while` `(arr[index] > 1``                   ``&& arr[index] % K == 0) {``                ``arr[index] = arr[index] / K;``                ``total_division++;``            ``}``        ``}``    ``}` `    ``sort(arr, arr + N);` `    ``// Update maximum element and``    ``// decrement total_division``    ``while` `(total_division > 0) {``        ``arr[N - 1] = K * arr[N - 1];``        ``total_division--;``    ``}` `    ``int` `maximum_sum = 0;``    ``for` `(``int` `index = 0; index < N;``         ``index++) {``        ``maximum_sum += arr[index];``    ``}` `    ``// Return maximum_sum``    ``return` `maximum_sum;``}` `// Driver Code``int` `main()``{``    ``int` `arr = { 1, 2, 3, 4, 5 };``    ``int` `N = 5, K = 2;` `    ``// Function called``    ``cout << MaximumSumOperations(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``public` `class` `GFG``{` `  ``// Utility function``  ``static` `int` `MaximumSumOperations(``int` `arr[], ``int` `N,``                                  ``int` `K)``  ``{``    ``if` `(N == ``1``) {``      ``return` `arr[``0``];``    ``}` `    ``// Variable to count total operations``    ``int` `total_division = ``0``;` `    ``// Perform the division operation on``    ``// the elements multiple of K``    ``for` `(``int` `index = ``0``; index < N;``         ``index++) {``      ``if` `(arr[index] % K == ``0``) {``        ``while` `(arr[index] > ``1``               ``&& arr[index] % K == ``0``) {``          ``arr[index] = arr[index] / K;``          ``total_division++;``        ``}``      ``}``    ``}` `    ``Arrays.sort(arr);` `    ``// Update maximum element and``    ``// decrement total_division``    ``while` `(total_division > ``0``) {``      ``arr[N - ``1``] = K * arr[N - ``1``];``      ``total_division--;``    ``}` `    ``int` `maximum_sum = ``0``;``    ``for` `(``int` `index = ``0``; index < N;``         ``index++) {``      ``maximum_sum += arr[index];``    ``}` `    ``// Return maximum_sum``    ``return` `maximum_sum;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String args[])``  ``{``    ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5` `};``    ``int` `N = ``5``, K = ``2``;` `    ``// Function called``    ``System.out.println(MaximumSumOperations(arr, N, K));``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# Python code for the above approach` `# Utility function``def` `MaximumSumOperations(arr, N, K):``    ``if` `(N ``=``=` `1``):``        ``return` `arr[``0``];` `    ``# Variable to count total operations``    ``total_division ``=` `0``;` `    ``# Perform the division operation on``    ``# the elements multiple of K``    ``for` `index ``in` `range``(N):``        ``if` `(arr[index] ``%` `K ``=``=` `0``):``            ``while` `(arr[index] > ``1` `and` `arr[index] ``%` `K ``=``=` `0``):``                ``arr[index] ``=` `arr[index] ``/``/` `K;``                ``total_division ``+``=` `1` `    ``arr.sort()` `    ``# Update maximum element and``    ``# decrement total_division``    ``while` `(total_division > ``0``):``        ``arr[N ``-` `1``] ``=` `K ``*` `arr[N ``-` `1``];``        ``total_division ``-``=` `1` `    ``maximum_sum ``=` `0``;``    ``for` `index ``in` `range``(N):``        ``maximum_sum ``+``=` `arr[index];` `    ``# Return maximum_sum``    ``return` `maximum_sum;` `# Driver Code``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``]``N ``=` `5``K ``=` `2` `# Function called``print``(MaximumSumOperations(arr, N, K));` `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{``  ` `  ``// Utility function``  ``static` `int` `MaximumSumOperations(``int` `[]arr, ``int` `N,``                                  ``int` `K)``  ``{``    ``if` `(N == 1) {``      ``return` `arr;``    ``}` `    ``// Variable to count total operations``    ``int` `total_division = 0;` `    ``// Perform the division operation on``    ``// the elements multiple of K``    ``for` `(``int` `index = 0; index < N;``         ``index++) {``      ``if` `(arr[index] % K == 0) {``        ``while` `(arr[index] > 1``               ``&& arr[index] % K == 0) {``          ``arr[index] = arr[index] / K;``          ``total_division++;``        ``}``      ``}``    ``}` `    ``Array.Sort(arr);` `    ``// Update maximum element and``    ``// decrement total_division``    ``while` `(total_division > 0) {``      ``arr[N - 1] = K * arr[N - 1];``      ``total_division--;``    ``}` `    ``int` `maximum_sum = 0;``    ``for` `(``int` `index = 0; index < N;``         ``index++) {``      ``maximum_sum += arr[index];``    ``}` `    ``// Return maximum_sum``    ``return` `maximum_sum;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int` `[]arr = { 1, 2, 3, 4, 5 };``    ``int` `N = 5, K = 2;` `    ``// Function called``    ``Console.Write(MaximumSumOperations(arr, N, K));``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output
`46`

Time Complexity: O(N * logN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up