# Maximize sum of given array by rearranging array such that the difference between adjacent elements is atmost 1

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

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++

 `// C++ program for the above approach``#include ``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 frequency``    ``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);` `    ``// Function Call``    ``cout << (maxSum(arr, n));``    ``return` `0;``}` `// This code is contributed by akhilsaini`

## Java

 `// 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 frequency``        ``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));``    ``}``}`

## Python3

 `# 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 frequency``    ``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`

## C#

 `// 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 frequency``    ``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`

## Javascript

 ``

Output:

`6`

Time Complexity: O(N), where N is the size of the given array. As we are using a loop to traverse the array N times.
Auxiliary Space: O(N), as we are using a extra space for count array.

My Personal Notes arrow_drop_up