# Maximize distinct elements of Array by combining two elements or splitting an element

• Last Updated : 09 May, 2022

Given an array arr[] of length N, the task is to maximize the number of distinct elements in the array by performing either of the following operations, any number of times:

1. For an index i(0 â‰¤ i < N), replace arr[i] with a and b such that arr[i] = a + b.
2. For two indices i (0 â‰¤ i < N) and n (0 â‰¤ n < N), Replace arr[n] with (arr[i] + arr[n]). Pop arr[i] from the array.

Examples:

Input: arr[] = {1, 4, 2, 8}, N = 4
Output: 5
Explanation: arr[3] can be split into [3, 5] to form arr [] = {1, 4, 2, 3, 5}.
There is no other way to split this into more elements.

Input: arr[] = {1, 1, 4, 3}, N = 4
Output: 3
Explanation: No operations can be performed to increase the number of distinct elements.

Approach: The problem can be based on the following observation:

Using the second operation, the entire arr[] can be reduced to 1 element, such that arr[0] = sum(arr[]). Now, the array sum can be partitioned into maximum number of unique parts get maximum unique elements.

Follow the below steps to implement the observation:

• Iterate over the array and find the sum of array elements (say sum).
• Now to get the maximum unique partitions of sum, it is optimal to assign as low a value as possible to each part.
• So, loop from i = 1 as long as sum > 0:
• Subtract i from sum and then increment i by 1.
• The total number of unique elements is i – 1, as there is an extra incrementation at the last iteration of the loop.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the above approach`   `#include ` `using` `namespace` `std;`   `// Function to calculate the maximum possible` `// number of unique elements` `int` `maxUniqueElems(``int``* Arr, ``int` `L)` `{` `    ``// Initializing sums variable` `    ``int` `sums = 0;`   `    ``// Calculating sum of array` `    ``for` `(``int` `j = 0; j < L; j++)` `        ``sums += Arr[j];`   `    ``// Initializing i to count total number of` `    ``// distinct elements` `    ``int` `i = 1;`   `    ``// Looping till sums becomes 0` `    ``while` `(sums > 0) {`   `        ``// Subtracting i from sums and` `        ``// incrementing i` `        ``sums -= i;` `        ``i++;` `    ``}`   `    ``// Returning the result` `    ``return` `i - 1;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 4, 2, 8 };` `    ``int` `N = 4;`   `    ``// Function call` `    ``cout << maxUniqueElems(arr, N);` `    ``return` `0;` `}`

## Java

 `// JAVA code to implement the above approach`   `import` `java.util.*;` `class` `GFG` `{` `  `  `    ``// Function to calculate the maximum possible` `    ``// number of unique elements` `    ``public` `static` `int` `maxUniqueElems(``int` `[]Arr, ``int` `L)` `    ``{` `        ``// Initializing sums variable` `        ``int` `sums = ``0``;` `    `  `        ``// Calculating sum of array` `        ``for` `(``int` `j = ``0``; j < L; j++)` `            ``sums += Arr[j];` `    `  `        ``// Initializing i to count total number of` `        ``// distinct elements` `        ``int` `i = ``1``;` `    `  `        ``// Looping till sums becomes 0` `        ``while` `(sums > ``0``) {` `    `  `            ``// Subtracting i from sums and` `            ``// incrementing i` `            ``sums -= i;` `            ``i++;` `        ``}` `    `  `        ``// Returning the result` `        ``return` `i - ``1``;` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `main(String []args)` `    ``{` `        ``int` `arr[] = ``new` `int``[]{ ``1``, ``4``, ``2``, ``8` `};` `        ``int` `N = ``4``;` `    `  `        ``// Function call` `        ``System.out.println(maxUniqueElems(arr, N));` `    ``}` `}`   `// This code is contributed by Taranpreet`

## Python3

 `# python3 code to implement the above approach`   `# Function to calculate the maximum possible` `# number of unique elements` `def` `maxUniqueElems(Arr, L):`   `    ``# Initializing sums variable` `    ``sums ``=` `0`   `    ``# Calculating sum of array` `    ``for` `j ``in` `range``(``0``, L):` `        ``sums ``+``=` `Arr[j]`   `    ``# Initializing i to count total number of` `    ``# distinct elements` `    ``i ``=` `1`   `    ``# Looping till sums becomes 0` `    ``while` `(sums > ``0``):`   `        ``# Subtracting i from sums and` `        ``# incrementing i` `        ``sums ``-``=` `i` `        ``i ``+``=` `1`   `    ``# Returning the result` `    ``return` `i ``-` `1`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``1``, ``4``, ``2``, ``8``]` `    ``N ``=` `4`   `    ``# Function call` `    ``print``(maxUniqueElems(arr, N))`   `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# code to implement the above approach`   `using` `System;` `class` `GFG {`   `  ``// Function to calculate the maximum possible` `  ``// number of unique elements` `  ``static` `int` `maxUniqueElems(``int``[] Arr, ``int` `L)` `  ``{` `    ``// Initializing sums variable` `    ``int` `sums = 0;`   `    ``// Calculating sum of array` `    ``for` `(``int` `j = 0; j < L; j++)` `      ``sums += Arr[j];`   `    ``// Initializing i to count total number of` `    ``// distinct elements` `    ``int` `i = 1;`   `    ``// Looping till sums becomes 0` `    ``while` `(sums > 0) {`   `      ``// Subtracting i from sums and` `      ``// incrementing i` `      ``sums -= i;` `      ``i++;` `    ``}`   `    ``// Returning the result` `    ``return` `i - 1;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] arr = { 1, 4, 2, 8 };` `    ``int` `N = 4;`   `    ``// Function call` `    ``Console.WriteLine(maxUniqueElems(arr, N));` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`5`

Time Complexity: O(max(N, sqrt(S))) where S is the sum of array
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles