Open In App

Minimum operations required to Sort the Array using following operations

Improve
Improve
Like Article
Like
Save
Share
Report

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 and replace elements arr[i] == x equal to 0 for,  
0 ? i ? N – 1.

Examples:

Input: n = 3, arr[] = {3, 3, 2}
Output: 1
Explanation: If you choose x = 3 then after one operation array will become {0, 0, 2} which is sorted in non-decreasing order.

Input: n = 4, arr[] = {2, 4, 1, 2}
Output: 3
Explanation: First you can choose x = 2 then after one operation array will become {0, 4, 1, 0} and in the second operation you can choose x = 1 then after the operation array will become {0, 4, 0, 0} and at last you can choose x = 4 and the array will become {0, 0, 0, 0} which is sorted in non-decreasing order.

Approach: The problem can be solved based on the following idea:

This problem can be solved using a greedy approach. We know that an array is sorted in non-decreasing order if arr[i] <= arr[i+1] for all i. So as we get arr[i] > arr[i+1] then we have to set       x = arr[i]. So, the optimal idea is to traverse the array from the end and mark the index for which arr[i] > arr[i+1] and then count the different elements till that index.

Follow the below steps to implement the idea:

  • Find the last index from the end such that arr[i] > arr[i + 1].
  • If the array is already sorted then return 0.
  • Else make a visit[] of size n+1 which will be true only for those elements which should be zero to make the array sorted. 
  • To fill the visit[] we will run a loop from the end of the arr array and mark all the indexes till the last index as true and then from the last index+1 to n-index iterate the arr array and mark the vis index as true for which the element already exists. 
  • Now count the all true elements of the vis vector and return the answer.

Below is the implementation for the above approach:

C++




// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum operations
// to sort the array
int minMoves(int n, int arr[])
{
 
    // Variable to store the idx for which
    // arr[i] > arr[i + 1]
    int last = -1;
    for (int i = n - 2; i >= 0; i--) {
 
        if (arr[i] > arr[i + 1]) {
            last = i;
            break;
        }
    }
 
    // If no such element found then return 0
    if (last == -1) {
        return 0;
    }
 
    // Make a visit vector to store which
    // elements we need to make zero
    bool visit[n + 1];
 
    // Initially make all the elements as false
    for (int i = 1; i < n + 1; i++) {
 
        visit[i] = false;
    }
 
    // Mark the elements till the last index
    // as true
    for (int i = 0; i <= last; i++) {
 
        visit[arr[i]] = true;
    }
 
    // After the last index mark the index
    // last for which elements are repeating
    for (int i = last + 1; i < n; i++) {
 
        if (visit[arr[i]] == true) {
            last = i;
        }
    }
 
    // Again mark all the elements before
    // last index as true
    for (int i = last; i >= 0; i--) {
 
        visit[arr[i]] = true;
    }
 
    int ans = 0;
 
    // Count the number of elements which
    // are true in visit vector
    for (int i = 1; i <= n; i++) {
 
        if (visit[i] == true) {
            ans++;
        }
    }
 
    // Return the count
    return ans;
}
 
// Driver Code
int main()
{
 
    // Test Case 1
    int n = 3;
    int arr[] = { 3, 3, 2 };
 
    // Function call
    cout << minMoves(n, arr) << endl;
 
    // Test Case 2
    n = 4;
    int arr1[] = { 2, 4, 1, 2 };
 
    // Function call
    cout << minMoves(n, arr1) << endl;
    return 0;
}


Java




// Java code for the above approach
import java.io.*;
import java.util.*;
 
class GFG {
 
  // Function to find the minimum operations
  // to sort the array
  public static int minMoves(int n, int[] arr)
  {
    // Variable to store the idx for which
    // arr[i] > arr[i + 1]
    int last = -1;
    for (int i = n - 2; i >= 0; i--) {
      if (arr[i] > arr[i + 1]) {
        last = i;
        break;
      }
    }
 
    // If no such element found then return 0
    if (last == -1) {
      return 0;
    }
 
    // Make a visit vector to store which
    // elements we need to make zero
    boolean[] visit = new boolean[n + 1];
 
    // Initially make all the elements as false
    Arrays.fill(visit, false);
 
    // Mark the elements till the last index
    // as true
    for (int i = 0; i <= last; i++) {
      visit[arr[i]] = true;
    }
 
    // After the last index mark the index
    // last for which elements are repeating
    for (int i = last + 1; i < n; i++) {
      if (visit[arr[i]] == true) {
        last = i;
      }
    }
 
    // Again mark all the elements before
    // last index as true
    for (int i = last; i >= 0; i--) {
      visit[arr[i]] = true;
    }
 
    int ans = 0;
 
    // Count the number of elements which
    // are true in visit vector
    for (int i = 1; i <= n; i++) {
      if (visit[i] == true) {
        ans++;
      }
    }
 
    // Return the count
    return ans;
  }
 
  public static void main(String[] args)
  {
    // Test Case 1
    int n = 3;
    int[] arr = { 3, 3, 2 };
 
    // Function call
    System.out.println(minMoves(n, arr));
 
    // Test Case 2
    n = 4;
    int[] arr1 = { 2, 4, 1, 2 };
 
    // Function call
    System.out.println(minMoves(n, arr1));
  }
}
 
// This code is contributed by lokesh.


Python3




# Python code for the above approach
 
# Function to find the minimum operations
# to sort the array
def minMoves(n,arr):
    # Variable to store the idx for which
    # arr[i] > arr[i + 1]
    last=-1
    for i in range(n-2,-1,-1):
        if(arr[i]>arr[i+1]):
            last=i
            break
     
    # If no such element found then return 0
    if(last==-1):
        return 0
     
    # Make a visit vector to store which
    # elements we need to make zero
    visit=[True]*(n+1)
     
    # Initially make all the elements as false
    for i in range(1,n+1):
        visit[i]=False
     
    # Mark the elements till the last index
    # as true
    for i in range(0,last+1):
        visit[arr[i]]=True
     
    # After the last index mark the index
    # last for which elements are repeating
    for i in range(last+1,n):
        if(visit[arr[i]]==True):
            last=i
     
    # Again mark all the elements before
    # last index as true
    for i in range(last,-1,-1):
        visit[arr[i]]=True
     
    ans=0
     
    # Count the number of elements which
    # are true in visit vector
    for i in range(1,n+1):
        if(visit[i]==True):
            ans+=1
             
    # Return the count
    return ans
     
# Driver code
 
# Test Case 1
n=3
arr=[3,3,2]
 
# Function call
print(minMoves(n,arr))
 
# Test Case 2
n=4
arr=[2,4,1,2]
 
# Function call
print(minMoves(n,arr))
 
# This code is contributed by Pushpesh Raj.


C#




// C# code for the above approach
using System;
using System.Linq;
 
public class GFG {
 
  // Function to find the minimum operations
  // to sort the array
  public static int minMoves(int n, int[] arr)
  {
     
    // Variable to store the idx for which
    // arr[i] > arr[i + 1]
    int last = -1;
    for (int i = n - 2; i >= 0; i--) {
      if (arr[i] > arr[i + 1]) {
        last = i;
        break;
      }
    }
 
    // If no such element found then return 0
    if (last == -1) {
      return 0;
    }
 
    // Make a visit vector to store which
    // elements we need to make zero
    bool[] visit = new bool[n + 1];
 
    // Initially make all the elements as false
    for (int i = 0; i <= n; i++) {
      visit[i] = false;
    }
 
    // Mark the elements till the last index
    // as true
    for (int i = 0; i <= last; i++) {
      visit[arr[i]] = true;
    }
 
    // After the last index mark the index
    // last for which elements are repeating
    for (int i = last + 1; i < n; i++) {
      if (visit[arr[i]] == true) {
        last = i;
      }
    }
 
    // Again mark all the elements before
    // last index as true
    for (int i = last; i >= 0; i--) {
      visit[arr[i]] = true;
    }
 
    int ans = 0;
 
    // Count the number of elements which
    // are true in visit vector
    for (int i = 1; i <= n; i++) {
      if (visit[i] == true) {
        ans++;
      }
    }
 
    // Return the count
    return ans;
  }
 
  static public void Main()
  {
 
    // Code
    // Test Case 1
    int n = 3;
    int[] arr = { 3, 3, 2 };
 
    // Function call
    Console.WriteLine(minMoves(n, arr));
 
    // Test Case 2
    n = 4;
    int[] arr1 = { 2, 4, 1, 2 };
 
    // Function call
    Console.WriteLine(minMoves(n, arr1));
  }
}
 
// This code is contributed by lokeshmvs21.


Javascript




  // JS code to implement the approach
 
  // Function to find the minimum operations
  // to sort the array
  function minMoves(n, arr) {
 
    // Variable to store the idx for which
    // arr[i] > arr[i + 1]
    let last = -1;
    for (let i = n - 2; i >= 0; i--) {
 
      if (arr[i] > arr[i + 1]) {
        last = i;
        break;
      }
    }
 
    // If no such element found then return 0
    if (last == -1) {
      return 0;
    }
 
    // Make a visit vector to store which
    // elements we need to make zero
    let visit = new Array(n + 1).fill(0);
 
    // Initially make all the elements as false
    for (let i = 1; i < n + 1; i++) {
 
      visit[i] = false;
    }
 
    // Mark the elements till the last index
    // as true
    for (let i = 0; i <= last; i++) {
 
      visit[arr[i]] = true;
    }
 
    // After the last index mark the index
    // last for which elements are repeating
    for (let i = last + 1; i < n; i++) {
 
      if (visit[arr[i]] == true) {
        last = i;
      }
    }
 
    // Again mark all the elements before
    // last index as true
    for (let i = last; i >= 0; i--) {
 
      visit[arr[i]] = true;
    }
 
    let ans = 0;
 
    // Count the number of elements which
    // are true in visit vector
    for (let i = 1; i <= n; i++) {
 
      if (visit[i] == true) {
        ans++;
      }
    }
 
    // Return the count
    return ans;
  }
 
  // Driver Code
 
 
  // Test Case 1
  let n = 3;
  let arr = [3, 3, 2];
 
  // Function call
  console.log(minMoves(n, arr) + "<br>");
 
  // Test Case 2
  n = 4;
  let arr1 = [2, 4, 1, 2];
 
  // Function call
  console.log(minMoves(n, arr1) + "<br>");
 
// This code is contributed by Potta Lokesh


Output

1
3

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

Related articles:



Last Updated : 30 Jan, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads