Minimum replacements with 0 to sort the array

Given an array A[] of N integers, the duty is to search out the minimal variety of operations to type the array in non-decreasing order, by selecting an integer X and changing all of the occurrences of X within the array with 0.

Examples:

Enter: N = 5, A[] = {2, 2, 1, 1, 3}
Output: 1
Rationalization: We select X = 2 and substitute all of the occurrences of two with 0. Now the array turns into {2, 2, 1, 1, 3} -> {0, 0, 1, 1, 3} , which is sorted in growing order.

Enter: N = 4, A[] = {2, 4, 1, 2}
Output: 3

Method: The issue will be solved simply with the assistance of a Map. 

Observations:

There are 2 instances that must be thought of :

• Case 1: Similar factor happens greater than as soon as non-contiguously 
  • Contemplate the array : {1,6,3,4,5,3,2}. 
  • Now, since 3 at index 5 is larger than its subsequent factor, so we are going to make that 0 (in addition to 3 at index 2). 
  • The array turns into {1,6,0,4,5,0,2}. 
  • So, the one strategy to type the array could be to make all the weather earlier than the zeroes equal to 0. i.e. the array turns into {0,0,0,0,0,0,2}.
• Case 2: Aspect at ith index is larger than the factor at (i+1)th index :
  • Contemplate the array : {1,2,3,5,4}. 
  • Because the factor on the third index is larger than the factor at 4th index, we now have to make the factor at third index equal to zero. 
  • So , the array turns into {1,2,3,0,4}. 
  • Now, the one strategy to type the array could be to make all the weather earlier than the zero equal to 0. i.e. the array turns into {0,0,0,0,4}.

It may be noticed that ultimately Case 2 breaks all the way down to Case 1.

Contemplating the above instances, the issue will be solved following the beneath steps :

• Declare a hash map and add the frequency of every factor of the array into the map.
• Iterate by the array from the again, i.e. from i=N-1 to i=0.
• At every iteration, deal with Instances 1 and a couple of as defined above.
• If iteration completes, return 0.

Beneath is the implementation of this method:

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