GeeksforGeeks App
Open App
Browser
Continue

# Minimize operations to make all elements equal by replacing left half of Subarray with right half

Given an array arr[] of length N, the task is to find the minimum operations to make all the array elements equal where in each operation:

• Choose any value K any subarray of even length 2*K
• Replace the left half of the subarray by the right half of the subarray.

Examples:

Input: arr[] = {4, 4, 4, 2, 4}
Output: 1
Explanation: In 1st operation choose index i = 3 and K = 1.
So subarray of 2K length of indices [3, 4] is chosen.
Replace first half by the second half. So it becomes {4, 4, 4, 4, 4}

Input: arr[] = {4, 2, 1, 3}
Output: 2
Explanation: In 1st operation choose index i = 2, K = 1.
The array converts to {4, 2, 3, 3}.
In the second operation choose index 0 and K = 2.
So the subarray of length 4 and first two gets replaced by the last two.
So the array becomes {3, 3, 3, 3}. So operations are 2.

Approach: This problem can be solved based on the following observation:

Observations:

The last element can never be changed with some other element since there are no elements to the right so all the previous elements must be equal to the last element.
To minimize the operations, keep as many same elements in the right half of the subarray as possible

Follow the steps mentioned below to solve the above problem:

• Initialize a variable res = 0 to store the operations required
• Traverse from the end of the array i = N – 2 to 0:
• Check if arr[i] is equal to last element
• If it is equal no operation is required
• Else there is a need to do an operation by choosing some K and an array of length 2*K and replace the first half with the second half.
• Consider arr[i] to be last element of the left half and (i+1 to N-1) to be the right half and replace all left half elements with the right half elements.
• So increment the res and move to index i = (i – (N – 1 – i)) to have minimum operations by replacing the whole half by the second half.
• Return the res as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count minimum operations``int` `min_ops(``int` `arr[], ``int` `n)``{``    ``int` `res = 0;``    ``int` `i = n - 1;``    ``while` `(i > 0) {` `        ``// Check if arr[i]== arr[n-1]``        ``// If they are equal do i--``        ``if` `(arr[i] == arr[n - 1]) {``            ``i--;``        ``}``        ``else` `{` `            ``// Try to do an operation` `            ``// It is always optimal to``            ``// to move to the index of``            ``// length n-1-i before i``            ``// since it is easy to replace``            ``// first half with second half``            ``res++;` `            ``// Move i to half of the``            ``// elements after that``            ``i -= (n - i - 1);``        ``}``    ``}``    ``return` `res;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 4, 2, 1, 3 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``cout << min_ops(arr, N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG {` `  ``// Function to count minimum operations``  ``static` `int` `min_ops(``int` `arr[], ``int` `n)``  ``{``    ``int` `res = ``0``;``    ``int` `i = n - ``1``;``    ``while` `(i > ``0``) {` `      ``// Check if arr[i]== arr[n-1]``      ``// If they are equal do i--``      ``if` `(arr[i] == arr[n - ``1``]) {``        ``i--;``      ``}``      ``else` `{` `        ``// Try to do an operation` `        ``// It is always optimal to``        ``// to move to the index of``        ``// length n-1-i before i``        ``// since it is easy to replace``        ``// first half with second half``        ``res++;` `        ``// Move i to half of the``        ``// elements after that``        ``i -= (n - i - ``1``);``      ``}``    ``}``    ``return` `res;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args) {``    ``int` `arr[] = { ``4``, ``2``, ``1``, ``3` `};``    ``int` `N = arr.length;` `    ``// Function call``    ``System.out.print(min_ops(arr, N));``  ``}``}` `// This code is contributed by hrithikgarg03188.`

## Python3

 `# Python program for the above approach` `# Function to count minimum operations``def` `min_ops(arr, n):` `    ``res ``=` `0``    ``i ``=` `n ``-` `1``    ``while` `(i > ``0``):` `        ``# Check if arr[i]== arr[n-1]``        ``# If they are equal do i--``        ``if` `(arr[i] ``=``=` `arr[n ``-` `1``]):``            ``i ``=` `i``-``1` `        ``else``:` `            ``# Try to do an operation` `            ``# It is always optimal to``            ``# to move to the index of``            ``# length n-1-i before i``            ``# since it is easy to replace``            ``# first half with second half``            ``res ``=` `res ``+` `1` `            ``# Move i to half of the``            ``# elements after that``            ``i ``=` `i ``-` `(n ``-` `i ``-` `1``)` `    ``return` `res` `# Driver code` `arr ``=` `[``4``, ``2``, ``1``, ``3``]``N ``=` `len``(arr)` `# Function call``print``(min_ops(arr, N))` `# This code is contributed by Taranpreet`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG {` `  ``// Function to count minimum operations``  ``static` `int` `min_ops(``int``[] arr, ``int` `n)``  ``{``    ``int` `res = 0;``    ``int` `i = n - 1;``    ``while` `(i > 0) {` `      ``// Check if arr[i]== arr[n-1]``      ``// If they are equal do i--``      ``if` `(arr[i] == arr[n - 1]) {``        ``i--;``      ``}``      ``else` `{` `        ``// Try to do an operation` `        ``// It is always optimal to``        ``// to move to the index of``        ``// length n-1-i before i``        ``// since it is easy to replace``        ``// first half with second half``        ``res++;` `        ``// Move i to half of the``        ``// elements after that``        ``i -= (n - i - 1);``      ``}``    ``}``    ``return` `res;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int``[] arr = { 4, 2, 1, 3 };``    ``int` `N = arr.Length;` `    ``// Function call``    ``Console.Write(min_ops(arr, N));``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`2`

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

My Personal Notes arrow_drop_up