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;
}

Python3

# 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)

Java

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

// 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));
    }
}

Output

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

Minimum number of deques required to make the array sorted

harsh2024it1034

Improve

Article Tags :

Practice Tags :

Minimum operations required to sort the array

Similar Reads

Thank You!

What kind of Experience do you want to share?