304 North Cardinal St.
Dorchester Center, MA 02124

# Decrease operations to make all the weather of given Subarrays distinct

Given an arr[] of constructive integers and begin[] and finish[] arrays of size L, Which accommodates the beginning and finish indexes of L variety of non-intersecting sub-arrays as a begin[i] and finish[i]  for all (1 ≤ i ≤ L). An operation is outlined as under:

• Choose an ordered steady or non – steady a part of the sub-array after which add an integer let’s say A to all the components of the chosen half.

Then, the duty is to output the minimal quantity of given operations required to make all the weather of all given non – intersecting sub-arrays distinct.

Notice: If multiple sub-arrays accommodates the identical component, It doesn’t matter. Simply every sub-array ought to comprise distinct components in itself.

Examples:

Enter: arr[] = {2, 2, 1, 2, 3}, begin[] = {1, 3}, finish[] = {2, 5}
Output: 1
Rationalization: First sub-array : [start[1], finish[1]] = {2, 2}.
Second sub-array : [start[3], finish[5]] = {1, 2, 3}.
In First sub-array selected sub-sequence from index 1 to 1 as {2} and plus any integer random integer let say 1.Then, First sub-array = {3, 2}. Now, each sub-array accommodates distinct components in itself. Complete variety of required operation are 1.

Enter: arr[] = {1, 2, 3, 3, 4, 5}, begin[] = {1, 4}, finish[] = {3, 6}
Output: 0
Rationalization: It may be verified that sub-arrays {1, 2, 3} and {3, 4, 5} each are distinct in itself. Subsequently, complete variety of required operations are 0.

Method: Implement the thought under to unravel the issue

Making all the weather distinct in a sub-array by given operation solely relies upon upon the utmost frequency in an sub-array, If we transformed excessive frequent component in distinct kind then remainder of the frequencies lower than max frequency will be make distinct concurrently. For extra readability see the  idea of method.Acquire the utmost frequency in every sub-array and apply the algorithm offered under.

Idea of method:

Suppose our sub-array A[] is = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2}. Highest frequency is 10 right here.

First operation: Selected ordered sub-sequence from index 6 to 10 and add any integer let say 1 to all components in sub-sequence. Then,   A[] = {2, 2, 2, 2, 2, 3, 3, 3, 3, 3}. Highest frequency is 5 until right here.

Second Operation: Selected ordered sub-sequence from index 3 to five and eight to 10 add any integer let say 2 to all components in sub-sequence. Then,  A[] = {2, 2, 4, 4, 4, 3, 3, 5, 5, 5}. Highest frequency is 3 until right here.

Third Operation: Selected ordered sub-sequence from index 4 to five and 9 to 10 add any integer let say 3 to all components in sub-sequence. Then,  A[] = {2, 2, 4, 7, 7, 3, 3, 5, 8, 8}

Fourth Operation: Selected ordered sub-sequence of indices : {1, 4, 6, 9}  add any integer let say 10 to all components in sub-sequence. Then,  A[] = {12, 2, 4, 17, 7, 13, 3, 5, 18, 8}

Thus, Solely 4 operation are required to transform into distinct components. At second operation we will see the each 2 and three component has 5 frequency and we efficiently convert them into distinct components. This offers us concept that If we attempt to make max frequent component distinct, Then remainder of the weather having frequency lower than or equal to max frequency will be transformed into distinct concurrently.

In above instance, It may be clearly seen that, At every operation we’re changing the precisely half of the components, If worth of max_frequency is even at that present operation in any other case we’re changing (max_frequency+1)/2 components in addition to we’re lowering the worth of max_frequency in the identical method.Thus we will conclude the under offered algorithm to unravel the issue.

Algorithm to unravel the issue:

1. Create a variable let’s say min_operations to retailer complete variety of minimal operations required for all              sub-arrays.

2. For Every given sub-array observe the steps under:

•  Depend frequency of every component and retailer them in Hash-Map.
• Traverse the Hash-Map to acquire most frequency in a variable let’s say max_frequency.
• Create and initialize counter variable to zero.
• Apply the under algorithm for acquiring minimal variety of operations required.

whereas(max_frequency > 1)
{
if (isEven(max_frequency))
{
max_frequency/=2;
}
else
{
max_frequency = (max_frequency+1)/2;
}
counter++;
}

• On finishing the loop add worth of counter variable in min_operations.

3. After apply above algorithm on every given sub-array print the worth of min_operations.

Beneath is the code to implement the method:

## Java

 ` `  `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;` ` `  `class` `GFG {` `    ` `    ``public` `static` `void` `major(String args[])` `    ``{` ` `  `        ` `        ``int``[] arr = { ``2``, ``2``, ``2``, ``2``, ``2``, ``3``, ``3``, ``3``, ``3``, ``3` `};` ` `  `        ` `        ` `        ``int``[] begin = { ``1``, ``6` `};` ` `  `        ` `        ` `        ``int``[] finish = { ``5``, ``10` `};` ` `  `        ` `        ` `        ``int` `min_operations = ``0``;` ` `  `        ` `        ` `        ``for` `(``int` `i = ``0``; i < begin.size; i++) {` ` `  `            ` `            ``int` `start_index = begin[i];` ` `  `            ` `            ``int` `end_index = finish[i];` ` `  `            ` `            ` `            ``HashMap map = ``new` `HashMap<>();` ` `  `            ` `            ` `            ``for` `(``int` `j = start_index - ``1``; j < end_index;` `                 ``j++) {` ` `  `                ` `                ` `                ``map.put(arr[j], map.get(arr[j]) == ``null` `                                    ``? ``1` `                                    ``: map.get(arr[j]) + ``1``);` `            ``}` ` `  `            ` `            ` `            ``int` `max_frequency = ``0``;` ` `  `            ` `            ``for` `(Map.Entry set :` `                 ``map.entrySet()) {` ` `  `                ` `                ` `                ``max_frequency` `                    ``= set.getValue() > max_frequency` `                          ``? set.getValue()` `                          ``: max_frequency;` `            ``}` ` `  `            ` `            ` `            ``whereas` `(max_frequency > ``1``) {` ` `  `                ` `                ``max_frequency` `                    ``= max_frequency % ``2` `== ``0` `                          ``? max_frequency / ``2` `                          ``: (max_frequency + ``1``) / ``2``;` ` `  `                ` `                ` `                ``min_operations++;` `            ``}` `        ``}` ` `  `        ` `        ` `        ``System.out.println(min_operations);` `    ``}` `}`

Time Complexity: O(N)
Auxiliary House: O(N)