 GeeksforGeeks App
Open App Browser
Continue

# Minimize operations to make all the elements of given Subarrays distinct

Given an arr[] of positive integers and start[] and end[] arrays of length L, Which contains the start and end indexes of L number of non-intersecting sub-arrays as a start[i] and end[i]  for all (1 ≤ i ≤ L). An operation is defined as below:

• Select an ordered continuous or non – continuous part of the sub-array and then add an integer let’s say A to all of the elements of the chosen part.

Then, the task is to output the minimum number of given operations required to make all the elements of all given non – intersecting sub-arrays distinct.

Note: If more than one sub-arrays contains the same element, It doesn’t matter. Just each sub-array should contain distinct elements in itself.

Examples:

Input: arr[] = {2, 2, 1, 2, 3}, start[] = {1, 3}, end[] = {2, 5}
Output: 1
Explanation: First sub-array : [start, end] = {2, 2}.
Second sub-array : [start, end] = {1, 2, 3}.
In First sub-array choose 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, both sub-array contains distinct elements in itself. Total number of required operation are 1.

Input: arr[] = {1, 2, 3, 3, 4, 5}, start[] = {1, 4}, end[] = {3, 6}
Output: 0
Explanation: It can be verified that sub-arrays {1, 2, 3} and {3, 4, 5} both are distinct in itself. Therefore, total number of required operations are 0.

Approach: Implement the idea below to solve the problem

Making all the elements distinct in a sub-array by given operation only depends upon the maximum frequency in an sub-array, If we converted high frequent element in distinct form then rest of the frequencies less than max frequency can be make distinct simultaneously. For more clarity see the  concept of approach.Obtain the maximum frequency in each sub-array and apply the algorithm provided below.

Concept of approach:

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

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

Second Operation: Choose ordered sub-sequence from index 3 to 5 and 8 to 10 add any integer let say 2 to all elements in sub-sequence. Then,  A[] = {2, 2, 4, 4, 4, 3, 3, 5, 5, 5}. Highest frequency is 3 till here.

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

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

Thus, Only four operation are required to convert into distinct elements. At second operation we can see the both 2 and 3 element has 5 frequency and we successfully convert them into distinct elements. This gives us idea that If we try to make max frequent element distinct, Then rest of the elements having frequency less than or equal to max frequency can be converted into distinct simultaneously.

In above example, It can be clearly seen that, At each operation we are converting the exactly half of the elements, If value of max_frequency is even at that current operation otherwise we are converting (max_frequency+1)/2 elements as well as we are reducing the value of max_frequency in the same manner.Thus we can conclude the below provided algorithm to solve the problem.

Algorithm to solve the problem:

1. Create a variable let’s say min_operations to store total number of minimum operations required for all              sub-arrays.

2. For Each given sub-array follow the steps below:

•  Count frequency of each element and store them in Hash-Map.
• Traverse the Hash-Map to obtain maximum frequency in a variable let’s say max_frequency.
• Create and initialize counter variable to zero.
• Apply the below algorithm for obtaining minimum number of operations required.

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

• On completing the loop add value of counter variable in min_operations.

3. After apply above algorithm on each given sub-array print the value of min_operations.

Below is the code to implement the approach:

## C++

```#include <bits/stdc++.h>
using namespace std;

// Driver Function
int main()
{

// Input arr[]
int arr = { 2, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
int arrlength = 10;

// start[] array holding start
// indices of sub-arrays
int start = { 1, 6 };
int startlength = 2;

// end[] array holding end
// indices of sub-arrays
int end = { 5, 10 };
int endlength = 2;

// Variable to hold total Minimum
// numbers of operations required
int min_operations = 0;

// Loop for traversing on given
// indices of sub-arrays sub-arrays
for (int i = 0; i < startlength; i++) {

// Start index of sub-array
int start_index = start[i];

// End index of sub-array
int end_index = end[i];

// HashMap for counting
// frequencies
unordered_map<int, int> map;

// Loop for traversing
// on sub-array
for (int j = start_index - 1; j < end_index; j++) {

// Obtaining and putting
// frequencies in map
map[arr[j]] == 0
? map[arr[j]] = 1
: map[arr[j]] = map[arr[j]] + 1;
}

// Variable to store
// max_frequency from map
int max_frequency = 0;

// Loop for traversing on map
// for (Map.Entry<Integer, Integer> set :
//      map.entrySet())
for (auto set : map) {

// Updating variable
// max_frequency
max_frequency = set.second > max_frequency
? set.second
: max_frequency;
}

// Applying discussed algorithm
// in concept of approach
while (max_frequency > 1) {

// Updating max_frequency variable
max_frequency = max_frequency % 2 == 0
? max_frequency / 2
: (max_frequency + 1) / 2;

// Incrementing
// min_operations
min_operations++;
}
}

// Printing minimum numbers
// of required operations
cout << min_operations;

return 0;
}

// This code is contributed by akashish__```

## Java

```// Java code to implement the approach

import java.io.*;
import java.lang.*;
import java.util.*;

class GFG {
// Driver Function
public static void main(String args[])
{

// Input arr[]
int[] arr = { 2, 2, 2, 2, 2, 3, 3, 3, 3, 3 };

// start[] array holding start
// indices of sub-arrays
int[] start = { 1, 6 };

// end[] array holding end
// indices of sub-arrays
int[] end = { 5, 10 };

// Variable to hold total Minimum
// numbers of operations required
int min_operations = 0;

// Loop for traversing on given
// indices of sub-arrays sub-arrays
for (int i = 0; i < start.length; i++) {

// Start index of sub-array
int start_index = start[i];

// End index of sub-array
int end_index = end[i];

// HashMap for counting
// frequencies
HashMap<Integer, Integer> map = new HashMap<>();

// Loop for traversing
// on sub-array
for (int j = start_index - 1; j < end_index;
j++) {

// Obtaining and putting
// frequencies in map
map.put(arr[j], map.get(arr[j]) == null
? 1
: map.get(arr[j]) + 1);
}

// Variable to store
// max_frequency from map
int max_frequency = 0;

// Loop for traversing on map
for (Map.Entry<Integer, Integer> set :
map.entrySet()) {

// Updating variable
// max_frequency
max_frequency
= set.getValue() > max_frequency
? set.getValue()
: max_frequency;
}

// Applying discussed algorithm
// in concept of approach
while (max_frequency > 1) {

// Updating max_frequency variable
max_frequency
= max_frequency % 2 == 0
? max_frequency / 2
: (max_frequency + 1) / 2;

// Incrementing
// min_operations
min_operations++;
}
}

// Printing minimum numbers
// of required operations
System.out.println(min_operations);
}
}```

## Python3

```# Python code to implement the approach

# Driver Function

#Input arr[]
arr = [2, 2, 2, 2, 2, 3, 3, 3, 3, 3]
arrlength = 10

# start[] array holding start
# indices of sub-arrays
start = [1, 6]
startlength = 2

# end[] array holding end
# indices of sub-arrays
end = [5, 10]
endlength = 2

# Variable to hold total Minimum
# numbers of operations required
min_operations = 0

# Loop for traversing on given
# indices of sub-arrays sub-arrays

for i in range(startlength):
# Start index of sub-array
start_index = start[i]

# End index of sub-array
end_index = end[i]

# HashMap for counting
# frequencies
map = dict()

# Loop for traversing
# on sub-array
for j in range(start_index-1,end_index):
# Obtaining and putting
# frequencies in map
if arr[j] in map.keys():
map[arr[j]] = map[arr[j]] + 1
else:
map[arr[j]] = 1

# Variable to store
# max_frequency from map
max_frequency = 0

# Loop for traversing on map
for key,value in map.items():
# Updating variable
# max_frequency
max_frequency = value if value>max_frequency else max_frequency

# Applying discussed algorithm
# in concept of approach
while(max_frequency > 1):
# Updating max_frequency variable
max_frequency=max_frequency//2 if max_frequency%2==0 else (max_frequency+1)//2

# Incrementing
# min_operations
min_operations=min_operations+1

# Printing minimum numbers
# of required operations
print(min_operations)

# This code is contributed by Aman Kumar.
```

## C#

```// Include namespace system
using System;
using System.Collections.Generic;
using System.Collections;

public class GFG
{
// Driver Function
public static void Main(String[] args)
{
// Input arr[]
int[] arr = {2, 2, 2, 2, 2, 3, 3, 3, 3, 3};

// start[] array holding start
// indices of sub-arrays
int[] start = {1, 6};

// end[] array holding end
// indices of sub-arrays
int[] end = {5, 10};

// Variable to hold total Minimum
// numbers of operations required
var min_operations = 0;

// Loop for traversing on given
// indices of sub-arrays sub-arrays
for (int i = 0; i < start.Length; i++)
{
// Start index of sub-array
var start_index = start[i];

// End index of sub-array
var end_index = end[i];

// HashMap for counting
// frequencies
var map = new Dictionary<int, int>();

// Loop for traversing
// on sub-array
for (int j = start_index - 1; j < end_index; j++)
{

// Obtaining and putting
// frequencies in map
map[arr[j]] = !map.ContainsKey(arr[j]) ? 1 : map[arr[j]] + 1;
}

// Variable to store
// max_frequency from map
var max_frequency = 0;

// Loop for traversing on map
foreach (KeyValuePair<int, int> entry in map)
{

// Updating variable
// max_frequency
max_frequency = entry.Value > max_frequency ? entry.Value : max_frequency;
}

// Applying discussed algorithm
// in concept of approach
while (max_frequency > 1)
{

// Updating max_frequency variable
max_frequency = max_frequency % 2 == 0 ? (int)(max_frequency / 2) : (int)((max_frequency + 1) / 2);

// Incrementing
// min_operations
min_operations++;
}
}

// Printing minimum numbers
// of required operations
Console.WriteLine(min_operations);
}
}

// This code is contributed by aadityaburujwale.```

## Javascript

```// Driver Function
// Input arr[]
let arr = [2, 2, 2, 2, 2, 3, 3, 3, 3, 3];
let arrlength = 10;

// start[] array holding start
// indices of sub-arrays
let start = [1, 6];
let startlength = 2;

// end[] array holding end
// indices of sub-arrays
let end = [5, 10];
let endlength = 2;

// Variable to hold total Minimum
// numbers of operations required
let min_operations = 0;

// Loop for traversing on given
// indices of sub-arrays sub-arrays
for (let i = 0; i < startlength; i++) {

// Start index of sub-array
let start_index = start[i];

// End index of sub-array
let end_index = end[i];

// HashMap for counting
// frequencies
let map = {};
for (let j = start_index - 1; j < end_index; j++) {

// Obtaining and putting
// frequencies in map
map[arr[j]] = 0;
}

// Loop for traversing
// on sub-array
for (let j = start_index - 1; j < end_index; j++) {

// Obtaining and putting
// frequencies in map
map[arr[j]] == 0
? map[arr[j]] = 1
: map[arr[j]] = map[arr[j]] + 1;
}

// Variable to store
// max_frequency from map
let max_frequency = 0;

// Loop for traversing on map
for (const [key, value] of Object.entries(map)) {
max_frequency = value > max_frequency
? value
: max_frequency;
}

// Applying discussed algorithm
// in concept of approach
while (max_frequency > 1) {

// Updating max_frequency variable
max_frequency = max_frequency % 2 == 0
? Math.floor(max_frequency / 2)
: Math.floor((max_frequency + 1) / 2);

// Incrementing
// min_operations
min_operations++;
}
}

// Printing minimum numbers
// of required operations
console.log(min_operations);

// This code is contributed by akashish__```
Output

`6`

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

My Personal Notes arrow_drop_up