Minimum operations required to sort the array
Last Updated :
15 Mar, 2023
Given an array arr[], the task is to find the minimum operations required to sort the array in increasing order. In one operation, you can set each occurrence of one element to 0.
Examples:
Input: item[] = [4, 1, 5, 3, 2]
Output: 4
Explanation: Set arr[0], arr[1], arr[2], arr[3] = 0. Hence, the minimum operations required is 4.
Input: item[] = [1, 3, 1, 3]
Output: 2
Explanation: Set arr[0] and arr[1] to 0. Array becomes = {0, 0, 0, 0}. Hence the minimum operations required is 2.
Approach: The problem can be solved based on the following idea:
In order to sort the array in increasing order, the condition a[i] ≤ a[i+1] must be followed at each and every instance. We iterate over the array and if we found the condition to be violating i.e. a[i] > a[i+1], So, in order to make a[i+1] greater, We will set all its previous non-zero elements to 0.
The previous element which has been assigned to zero will also set all its occurrences to zero.
Follow the steps mentioned below to implement the idea:
- Declare a map of int and vector which stores the index of each element.
- Declare queue which stores the count of previously non-zero elements for each index.
- Start iterating over the array and if a[i] > a[i+1], increase the count by the size of the queue (which is the count of non-zero elements appearing before it)
- Iterate over the queue till it becomes empty and set the occurrence of each element to zero which has previously set to zero.
- Return the count.
Below is the implementation of the above approach:
C++
// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
// Function for calculating
// minimum opeartions
int minimum_operations(vector<int>& arr, int n)
{
// Declare map for storing the index
// of each element.
map<int, vector<int> > mpp;
for (int i = 0; i < arr.size(); i++) {
mpp[arr[i]].push_back(i);
}
// Declare queue which store the count
// of previously non zero element.
queue<int> q;
set<int> st;
// Count the total opeartions
int count = 0;
for (int i = 0; i < n - 1; i++) {
if (st.find(arr[i]) == st.end() && arr[i] != 0) {
q.push(arr[i]);
st.insert(arr[i]);
}
// If found the violating condition
if (arr[i] > arr[i + 1]) {
// Increase the count by the
// previously non zero elements
count += q.size();
while (!q.empty()) {
int top = q.front();
q.pop();
if (mpp.find(top) != mpp.end()) {
// Set all occurences of
// previously assigned zero
// elements to zero
vector<int> idx = mpp[top];
for (int i = 0; i < idx.size(); i++) {
arr[idx[i]] = 0;
}
}
}
}
}
// Returning the count
return count;
}
// Driver code
int main()
{
vector<int> arr = { 4, 1, 5, 3, 2 };
int n = arr.size();
// Function call
cout << minimum_operations(arr, n);
return 0;
}
# Python implementation of above approach
from collections import defaultdict
# Function for calculating
# minimum operations
def minimum_operations(arr):
# Declare defaultdict for storing the
# index of each element
mpp = defaultdict(list)
for i, x in enumerate(arr):
mpp[x].append(i)
# Declare a queue which stores the count
# of previously non-zero elements
q = []
st = set()
# Count the total operations
count = 0
for i in range(len(arr) - 1):
if arr[i] not in st and arr[i] != 0:
q.append(arr[i])
st.add(arr[i])
# If found the violating condition
if arr[i] > arr[i + 1]:
# Increase the count by the
# previously non-zero elements
count += len(q)
while q:
top = q.pop(0)
if top in mpp:
# Set all occurrences of previously
# assigned zero elements to zero
for idx in mpp[top]:
arr[idx] = 0
# Returning the count
return count
# Driver code
arr = [4, 1, 5, 3, 2]
# Function call
print(minimum_operations(arr))
# This Code is Contributed by Prasad Kandekar(prasad264)
import java.util.*;
public class Main {
// Function for calculating minimum operations
public static int minimum_operations(List<Integer> arr,
int n)
{
// Declare map for storing the index of each
// element.
Map<Integer, List<Integer> > mpp = new HashMap<>();
for (int i = 0; i < arr.size(); i++) {
int num = arr.get(i);
if (!mpp.containsKey(num)) {
mpp.put(num, new ArrayList<Integer>());
}
mpp.get(num).add(i);
}
// Declare queue which store the count of previously
// non zero element.
Queue<Integer> q = new LinkedList<>();
Set<Integer> st = new HashSet<>();
// Count the total operations
int count = 0;
for (int i = 0; i < n - 1; i++) {
if (!st.contains(arr.get(i))
&& arr.get(i) != 0) {
q.offer(arr.get(i));
st.add(arr.get(i));
}
// If found the violating condition
if (arr.get(i) > arr.get(i + 1)) {
// Increase the count by the previously non
// zero elements
count += q.size();
while (!q.isEmpty()) {
int top = q.poll();
if (mpp.containsKey(top)) {
// Set all occurrences of previously
// assigned zero elements to zero
List<Integer> idx = mpp.get(top);
for (int j = 0; j < idx.size();
j++) {
arr.set(idx.get(j), 0);
}
}
}
}
}
// Returning the count
return count;
}
// Driver code
public static void main(String[] args)
{
List<Integer> arr
= new ArrayList<>(Arrays.asList(4, 1, 5, 3, 2));
int n = arr.size();
// Function call
System.out.println(minimum_operations(arr, n));
}
}
// Javascript implementation of above approach
// Function for calculating
// minimum opeartions
function minimum_operations(arr) {
// Declare map for storing the index
// of each element.
let mpp = new Map();
for (let i = 0; i < arr.length; i++) {
let val = arr[i];
if(mpp.has(val)) {
mpp.get(val).push(i);
}
else {
mpp.set(val, [i]);
}
}
// Declare queue which store the count
// of previously non zero element.
let q = [];
let st = new Set();
// Count the total opeartions
let count = 0;
for (let i = 0; i < arr.length - 1; i++) {
if (!st.has(arr[i]) && arr[i] !== 0) {
q.push(arr[i]);
st.add(arr[i]);
}
// If found the violating condition
if (arr[i] > arr[i + 1]) {
// Increase the count by the
// previously non zero elements
count += q.length;
while (q.length > 0) {
let top = q.shift();
if (mpp.has(top)) {
// Set all occurences of
// previously assigned zero
// elements to zero
let idx = mpp.get(top);
for (let i = 0; i < idx.length; i++) {
arr[idx[i]] = 0;
}
}
}
}
}
// Returning the count
return count;
}
// Driver code
let arr = [4, 1, 5, 3, 2];
console.log(minimum_operations(arr));
// This code is contributed by prasad264
using System;
using System.Collections.Generic;
class Program {
// Function for calculating minimum opeartions
static int minimum_operations(List<int> arr, int n)
{
// Declare map for storing the index of each element
Dictionary<int, List<int> > mpp
= new Dictionary<int, List<int> >();
for (int i = 0; i < arr.Count; i++) {
if (!mpp.ContainsKey(arr[i])) {
mpp[arr[i]] = new List<int>();
}
mpp[arr[i]].Add(i);
}
// Declare queue which store the count of previously
// non zero element
Queue<int> q = new Queue<int>();
HashSet<int> st = new HashSet<int>();
// Count the total opeartions
int count = 0;
for (int i = 0; i < n - 1; i++) {
if (!st.Contains(arr[i]) && arr[i] != 0) {
q.Enqueue(arr[i]);
st.Add(arr[i]);
}
// If found the violating condition
if (arr[i] > arr[i + 1]) {
// Increase the count by the previously non
// zero elements
count += q.Count;
while (q.Count > 0) {
int top = q.Dequeue();
if (mpp.ContainsKey(top)) {
// Set all occurences of previously
// assigned zero elements to zero
List<int> idx = mpp[top];
for (int j = 0; j < idx.Count;
j++) {
arr[idx[j]] = 0;
}
}
}
}
}
// Returning the count
return count;
}
// Driver code
static void Main(string[] args)
{
List<int> arr = new List<int>{ 4, 1, 5, 3, 2 };
int n = arr.Count;
// Function call
Console.WriteLine(minimum_operations(arr, n));
}
}
Time Complexity: O(NlogN)
Auxiliary Space: O(N)
Similar Reads
Minimize given operations required to sort the stream array Given an array stream of n integers in the form of a stream, the task is to find the minimum number of operations that are required to sort the stream (increasing order) following the below steps: In one operation you can pick up the first element and then put that element into the xth index. All th
6 min read
Minimum operations required to Sort the Array using following operations Given an array arr[] of size N. Make the array arr[] sorted in non-decreasing order in the minimum number of operations where you can choose any integer x and replace elements arr[i] == x equal to 0 for, 0 ? i ? N - 1. Examples: Input: n = 3, arr[] = {3, 3, 2}Output: 1Explanation: If you choose x =
10 min read
Minimum increment or decrement operations required to make the array sorted Given an array arr[] of N integers, the task is to sort the array in non-decreasing order by performing the minimum number of operations. In a single operation, an element of the array can either be incremented or decremented by 1. Print the minimum number of operations required.Examples: Input: arr
15+ min read
Minimum number of deques required to make the array sorted Given an array arr containing N unique integers. The task is to calculate the minimum number of deques required to make the array sorted. Example: Input: arr[] = {3, 6, 0, 9, 5, 4}Output: 2Explanation: Create a new deque d1 = {3}.Create a new deque d2 = {6}.Push 0 onto the front of d1; d1 = {0, 3}Pu
9 min read
Minimum range increment operations to Sort an array Given an array containing N elements. It is allowed to do the below move any number of times on the array: Choose any L and R and increment all numbers in range L to R by 1. The task is to find the minimum number of such moves required to sort the array in non decreasing order. Examples: Input : arr
5 min read