Related Articles

Related Articles

Maximize sum of given array by rearranging array such that the difference between adjacent elements is atmost 1
  • Difficulty Level : Medium
  • Last Updated : 25 Oct, 2020

Given an array arr[] consisting of N positive integers, the task is to maximize the sum of the array element such that the first element of the array is 1 and the difference between the adjacent elements of the array is at most 1 after performing the following operations:

  • Rearrange the array elements in any way.
  • Reduce any element to any number that is at least 1.

Examples:

Input: arr[] = {3, 5, 1}
Output: 6
Explanation:
One possible arrangement is {1, 2, 3} having maximum possible sum 6.

Input: arr[] = {1, 2, 2, 2, 3, 4, 5}
Output: 19
Explanation:
One possible arrangement is {1, 2, 2, 2, 3, 4, 5} having maximum possible sum 19.

Naive Approach: The simplest approach is to sort the given array then traverse in the sorted array and reduced the element that doesn’t satisfy the given condition. 



Time Complexity: O(N * log N), where N is the size of the given array.
Auxiliary Space: O(N)

Efficient Approach: The idea is to use the Hashing concept of storing the frequencies of the elements of the given array. Follow the below steps to solve the problem:

  • Create an auxiliary array count[] of size (N+1) to store frequency of arr[i].
  • While storing the frequency in count[] and if arr[i] greater than N then increment count[N].
  • Initialize the size and ans as 0 that stores the previously selected integer and maximum possible sum respectively.
  • Traverse the given array count[] array using variable K and do the following:
    • Iterate while a loop for each K until count[K] > 0 and size < K.
    • Increment size by 1 and ans by size and reduce count[K] by 1 inside while loop.
    • Increment ans with K*count[K] after the while loop ends.
  • After the above steps, print the value of ans as the maximum possible sum.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <iostream>
using namespace std;
  
// Function to find maximum possible
// sum after changing the array elements
// as per the given constraints
long maxSum(int a[], int n)
{
      
    // Stores the frequency of
    // elements in given array
    int count[n + 1] = {0};
  
    // Update frequncy
    for(int i = 0; i < n; i++)
        count[min(a[i], n)]++;
  
    // Stores the previously
    // selected integer
    int size = 0;
  
    // Stores the maximum possible sum
    long ans = 0;
  
    // Traverse over array count[]
    for(int k = 1; k <= n; k++) 
    {
          
        // Run loop for each k
        while (count[k] > 0 && size < k)
        {
            size++;
            ans += size;
            count[k]--;
        }
  
        // Update ans
        ans += k * count[k];
    }
  
    // Return maximum possible sum
    return ans;
}
  
// Driver Code
int main()
{
      
    // Given array arr[]
    int arr[] = { 3, 5, 1 };
  
    // Size of array
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    cout << (maxSum(arr, n));
    return 0;
}
  
// This code is contributed by akhilsaini

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
  
import java.util.*;
  
class GFG {
  
    // Function to find maximum possible
    // sum after changing the array elements
    // as per the given constraints
    static long maxSum(int[] a)
    {
        // Length of given array
        int n = a.length;
  
        // Stores the frequency of
        // elements in given array
        int[] count = new int[n + 1];
  
        // Update frequncy
        for (int x : a)
            count[Math.min(x, n)]++;
  
        // stores the previously
        // selected integer
        int size = 0;
  
        // Stores the maximum possible sum
        long ans = 0;
  
        // Traverse over array count[]
        for (int k = 1; k <= n; k++) {
  
            // Run loop for each k
            while (count[k] > 0 && size < k) {
                size++;
                ans += size;
                count[k]--;
            }
  
            // Update ans
            ans += k * count[k];
        }
  
        // Return maximum possible sum
        return ans;
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        // Given array arr[]
        int[] arr = { 3, 5, 1 };
  
        // Function Call
        System.out.println(maxSum(arr));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
  
# Function to find maximum possible
# sum after changing the array elements
# as per the given constraints
def maxSum(a, n):
  
    # Stores the frequency of
    # elements in given array
    count = [0] * (n + 1)
  
    # Update frequncy
    for i in range(0, n):
        count[min(a[i], n)] += 1
  
    # stores the previously
    # selected integer
    size = 0
  
    # Stores the maximum possible sum
    ans = 0
  
    # Traverse over array count[]
    for k in range(1, n + 1):
          
        # Run loop for each k
        while (count[k] > 0 and size < k):
            size += 1
            ans += size
            count[k] -= 1
  
        # Update ans
        ans += k * count[k]
  
    # Return maximum possible sum
    return ans
  
# Driver Code
if __name__ == '__main__':
  
    # Given array arr[]
    arr = [ 3, 5, 1 ]
  
    # Size of array
    n = len(arr)
  
    # Function Call
    print(maxSum(arr, n))
  
# This code is contributed by akhilsaini

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
  
class GFG{
  
// Function to find maximum possible
// sum after changing the array elements
// as per the given constraints
static long maxSum(int[] a)
{
      
    // Length of given array
    int n = a.Length;
  
    // Stores the frequency of
    // elements in given array
    int[] count = new int[n + 1];
  
    // Update frequncy
    for(int i = 0; i < n; i++)
        count[Math.Min(a[i], n)]++;
  
    // stores the previously
    // selected integer
    int size = 0;
  
    // Stores the maximum possible sum
    long ans = 0;
  
    // Traverse over array count[]
    for(int k = 1; k <= n; k++)
    {
          
        // Run loop for each k
        while (count[k] > 0 && size < k)
        {
            size++;
            ans += size;
            count[k]--;
        }
  
        // Update ans
        ans += k * count[k];
    }
  
    // Return maximum possible sum
    return ans;
}
  
// Driver Code
public static void Main()
{
      
    // Given array arr[]
    int[] arr = { 3, 5, 1 };
  
    // Function call
    Console.Write(maxSum(arr));
}
}
  
// This code is contributed by akhilsaini

chevron_right


Output: 

6



 

Time Complexity: O(N), where N is the size of the given array.
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up
Recommended Articles
Page :