Open in App
Not now

# Minimum operations required to Sort the Array using following operations

• Last Updated : 30 Jan, 2023

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 ` `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) + ``"
"``);`   `  ``// Test Case 2` `  ``n = 4;` `  ``let arr1 = [2, 4, 1, 2];`   `  ``// Function call` `  ``console.log(minMoves(n, arr1) + ``"
"``);`   `// This code is contributed by Potta Lokesh`

Output

```1
3```

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

Related articles:

My Personal Notes arrow_drop_up
Related Articles