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

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[0] = arr[0]/3 = 2, arr[1] = arr[1]*3 = 18, now the new array becomes, [2, 18, 3]
• Take i = 2 and j = 1, arr[2] = arr[2]/3 = 1, arr[1] = arr[1]*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[1] = arr[1]/2 = 1, arr[4] = arr[4]*2 = 10. Now arr[] = {1, 1, 3, 4, 10}. 
Take i = 3 and j = 4, arr[3] = arr[3]/2 = 2, arr[4] = arr[4]*2 = 20. Now arr[] = {1, 1, 3, 2, 20}.
Take i = 3 and j = 4, arr[3] = arr[3]/2 = 1, arr[4] = arr[4]*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]*K^X. 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++ code for the above approach
#include <bits/stdc++.h>
using namespace std;

// Utility function
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++;
            }
        }
    }

    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[5] = { 1, 2, 3, 4, 5 };
    int N = 5, K = 2;

    // Function called
    cout << MaximumSumOperations(arr, N, K);

    return 0;
}

// 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.

# 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# 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[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++;
        }
      }
    }

    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.

 <script>
        // JavaScript code for the above approach 

        // Utility function
        function MaximumSumOperations(arr, N, K) 
        {
            if (N == 1)
            {
                return arr[0];
            }

            // Variable to count total operations
            let total_division = 0;

            // Perform the division operation on
            // the elements multiple of K
            for (let index = 0; index < N;
                index++) {
                if (arr[index] % K == 0) {
                    while (arr[index] > 1
                        && arr[index] % K == 0) {
                        arr[index] = Math.floor(arr[index] / K);
                        total_division++;
                    }
                }
            }

            arr.sort(function (a, b) { return a - b })

            // Update maximum element and
            // decrement total_division
            while (total_division > 0) {
                arr[N - 1] = K * arr[N - 1];
                total_division--;
            }

            let maximum_sum = 0;
            for (let index = 0; index < N;
                index++) {
                maximum_sum += arr[index];
            }

            // Return maximum_sum
            return maximum_sum;
        }

        // Driver Code
        let arr = [1, 2, 3, 4, 5];
        let N = 5, K = 2;

        // Function called
        document.write(MaximumSumOperations(arr, N, K));

         // This code is contributed by Potta Lokesh
    </script>

46

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

geekyss

Follow

Improve

Article Tags :

• Greedy
• Sorting
• Algo Geek
• DSA
• Arrays
• Arrays

+2 More

Practice Tags :

• Arrays
• Arrays
• Greedy
• Sorting