Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimum increment or decrement operations required to make the array sorted

  • Difficulty Level : Expert
  • Last Updated : 04 Aug, 2021

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[] = {1, 2, 1, 4, 3} 
Output: 2 
Add 1 to the 3rd element(1) and subtract 1 from 
the 4th element(4) to get {1, 2, 2, 3, 3}
Input: arr[] = {1, 2, 2, 100} 
Output: 0 
Given array is already sorted. 
 

 

Observation: Since we would like to minimize the number of operations needed to sort the array the following should hold: 
 

  • A number will never be decreased to value lesser than the minimum of the initial array.
  • A number will never be increased to a value greater than the maximum of the initial array.
  • The number of operations required to change a number from X to Y is abs(X – Y).

Approach : Based on the above observation, this problem can be solved using dynamic programming. 
 

  1. Let DP(i, j) represent the minimum operations needed to make the 1st i elements of the array sorted in non-decreasing order when the ith element is equal to j.
  2. Now DP(N, j) needs to be calculated for all possible values of j where N is the size of the array. According to the observations, j ≥ smallest element of the initial array and j ≤ the largest element of the initial array.
  3. The base cases in the DP(i, j) where i = 1 can be easily answered. What are the minimum operations needes to sort the 1st element in non-decreasing order such that the 1st element is equal to j?. DP(1, j) = abs( array[1] – j).
  4. Now consider DP(i, j) for i > 1. If ith element is set to j then the 1st i – 1 elements need to be sorted and the (i – 1)th element has to be ≤ j i.e. DP(i, j) = (minimum of DP(i – 1, k) where k goes from 1 to j) + abs(array[i] – j) 
     
  5. Using the above recurrence relation and the base cases, the result can be easily calculated.

Below is the implementation of the above aprpoach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the minimum number
// of given operations required
// to sort the array
int getMinimumOps(vector<int> ar)
{
    // Number of elements in the array
    int n = ar.size();
 
    // Smallest element in the array
    int small = *min_element(ar.begin(), ar.end());
 
    // Largest element in the array
    int large = *max_element(ar.begin(), ar.end());
 
    /*
        dp(i, j) represents the minimum number
        of operations needed to make the
        array[0 .. i] sorted in non-decreasing
        order given that ith element is j
    */
    int dp[n][large + 1];
 
    // Fill the dp[]][ array for base cases
    for (int j = small; j <= large; j++) {
        dp[0][j] = abs(ar[0] - j);
    }
 
    /*
        Using results for the first (i - 1)
        elements, calculate the result
        for the ith element
    */
    for (int i = 1; i < n; i++) {
        int minimum = INT_MAX;
        for (int j = small; j <= large; j++) {
 
            /*
            If the ith element is j then we can have
            any value from small to j for the i-1 th
            element
            We choose the one that requires the
            minimum operations
        */
            minimum = min(minimum, dp[i - 1][j]);
            dp[i][j] = minimum + abs(ar[i] - j);
        }
    }
 
    /*
        If we made the (n - 1)th element equal to j
        we required dp(n-1, j) operations
        We choose the minimum among all possible
        dp(n-1, j) where j goes from small to large
    */
    int ans = INT_MAX;
    for (int j = small; j <= large; j++) {
        ans = min(ans, dp[n - 1][j]);
    }
 
    return ans;
}
 
// Driver code
int main()
{
    vector<int> ar = { 1, 2, 1, 4, 3 };
 
    cout << getMinimumOps(ar);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to return the minimum number
// of given operations required
// to sort the array
static int getMinimumOps(Vector<Integer> ar)
{
    // Number of elements in the array
    int n = ar.size();
 
    // Smallest element in the array
    int small = Collections.min(ar);
 
    // Largest element in the array
    int large = Collections.max(ar);
 
    /*
        dp(i, j) represents the minimum number
        of operations needed to make the
        array[0 .. i] sorted in non-decreasing
        order given that ith element is j
    */
    int [][]dp = new int[n][large + 1];
 
    // Fill the dp[]][ array for base cases
    for (int j = small; j <= large; j++)
    {
        dp[0][j] = Math.abs(ar.get(0) - j);
    }
 
    /*
        Using results for the first (i - 1)
        elements, calculate the result
        for the ith element
    */
    for (int i = 1; i < n; i++)
    {
        int minimum = Integer.MAX_VALUE;
        for (int j = small; j <= large; j++)
        {
 
            /*
            If the ith element is j then we can have
            any value from small to j for the i-1 th
            element
            We choose the one that requires the
            minimum operations
            */
            minimum = Math.min(minimum, dp[i - 1][j]);
            dp[i][j] = minimum + Math.abs(ar.get(i) - j);
        }
    }
 
    /*
        If we made the (n - 1)th element equal to j
        we required dp(n-1, j) operations
        We choose the minimum among all possible
        dp(n-1, j) where j goes from small to large
    */
    int ans = Integer.MAX_VALUE;
    for (int j = small; j <= large; j++)
    {
        ans = Math.min(ans, dp[n - 1][j]);
    }
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    Integer []arr = { 1, 2, 1, 4, 3 };
    Vector<Integer> ar = new Vector<>(Arrays.asList(arr));
 
    System.out.println(getMinimumOps(ar));
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the approach
 
# Function to return the minimum number
# of given operations required
# to sort the array
def getMinimumOps(ar):
     
    # Number of elements in the array
    n = len(ar)
 
    # Smallest element in the array
    small = min(ar)
 
    # Largest element in the array
    large = max(ar)
 
    """
        dp(i, j) represents the minimum number
        of operations needed to make the
        array[0 .. i] sorted in non-decreasing
        order given that ith element is j
    """
    dp = [[ 0 for i in range(large + 1)]
              for i in range(n)]
 
    # Fill the dp[]][ array for base cases
    for j in range(small, large + 1):
        dp[0][j] = abs(ar[0] - j)
    """
    /*
        Using results for the first (i - 1)
        elements, calculate the result
        for the ith element
    */
    """
    for i in range(1, n):
        minimum = 10**9
        for j in range(small, large + 1):
             
        # """
        #     /*
        #     If the ith element is j then we can have
        #     any value from small to j for the i-1 th
        #     element
        #     We choose the one that requires the
        #     minimum operations
        # """
            minimum = min(minimum, dp[i - 1][j])
            dp[i][j] = minimum + abs(ar[i] - j)
    """
    /*
        If we made the (n - 1)th element equal to j
        we required dp(n-1, j) operations
        We choose the minimum among all possible
        dp(n-1, j) where j goes from small to large
    */
    """
    ans = 10**9
    for j in range(small, large + 1):
        ans = min(ans, dp[n - 1][j])
 
    return ans
 
# Driver code
ar = [1, 2, 1, 4, 3]
 
print(getMinimumOps(ar))
 
# This code is contributed by Mohit Kumar
C#



// C# implementation of the approach
using System;
using System.Linq;
using System.Collections.Generic;            
     
class GFG
{
 
// Function to return the minimum number
// of given operations required
// to sort the array
static int getMinimumOps(List<int> ar)
{
    // Number of elements in the array
    int n = ar.Count;
 
    // Smallest element in the array
    int small = ar.Min();
 
    // Largest element in the array
    int large = ar.Max();
 
    /*
        dp(i, j) represents the minimum number
        of operations needed to make the
        array[0 .. i] sorted in non-decreasing
        order given that ith element is j
    */
    int [,]dp = new int[n, large + 1];
 
    // Fill the dp[], array for base cases
    for (int j = small; j <= large; j++)
    {
        dp[0, j] = Math.Abs(ar[0] - j);
    }
 
    /*
        Using results for the first (i - 1)
        elements, calculate the result
        for the ith element
    */
    for (int i = 1; i < n; i++)
    {
        int minimum = int.MaxValue;
        for (int j = small; j <= large; j++)
        {
 
            /*
            If the ith element is j then we can have
            any value from small to j for the i-1 th
            element
            We choose the one that requires the
            minimum operations
            */
            minimum = Math.Min(minimum, dp[i - 1, j]);
            dp[i, j] = minimum + Math.Abs(ar[i] - j);
        }
    }
 
    /*
        If we made the (n - 1)th element equal to j
        we required dp(n-1, j) operations
        We choose the minimum among all possible
        dp(n-1, j) where j goes from small to large
    */
    int ans = int.MaxValue;
    for (int j = small; j <= large; j++)
    {
        ans = Math.Min(ans, dp[n - 1, j]);
    }
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 1, 4, 3 };
    List<int> ar = new List<int>(arr);
 
    Console.WriteLine(getMinimumOps(ar));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
 
// Javascript implementation of the approach
 
// Function to return the minimum number
// of given operations required
// to sort the array
function getMinimumOps(ar)
{
    // Number of elements in the array
    var n = ar.length;
 
    // Smallest element in the array
    var small = Math.min.apply(Math,ar);
 
    // Largest element in the array
    var large = Math.max.apply(Math,ar);
 
    /*
        dp(i, j) represents the minimum number
        of operations needed to make the
        array[0 .. i] sorted in non-decreasing
        order given that ith element is j
    */
    var dp = new Array(n);
    var i,j;
    for(i=0;i<dp.length;i++)
        dp[i] = new Array(large+1);
 
    // Fill the dp[]][ array for base cases
    for (j = small; j <= large; j++) {
        dp[0][j] = Math.abs(ar[0] - j);
    }
 
    /*
        Using results for the first (i - 1)
        elements, calculate the result
        for the ith element
    */
    for (i = 1; i < n; i++) {
        var minimum = 2147483647;
        for (j = small; j <= large; j++) {
 
            /*
            If the ith element is j then we can have
            any value from small to j for the i-1 th
            element
            We choose the one that requires the
            minimum operations
        */
            minimum = Math.min(minimum, dp[i - 1][j]);
            dp[i][j] = minimum + Math.abs(ar[i] - j);
        }
    }
 
    /*
        If we made the (n - 1)th element equal to j
        we required dp(n-1, j) operations
        We choose the minimum among all possible
        dp(n-1, j) where j goes from small to large
    */
    var ans = 2147483647;
    for (j = small; j <= large; j++) {
        ans = Math.min(ans, dp[n - 1][j]);
    }
 
    return ans;
}
 
// Driver code
    var ar = [1, 2, 1, 4, 3];
 
    document.write(getMinimumOps(ar));
 
</script>
Output: 
2
 
Complexity Analysis: 
Time Complexity: O(N*R), Time complexity for the above approach is O(N * R) where N is the number of elements in the array and R = largest – smallest element of the array + 1.
Auxiliary Space: O(N * large)
 

My Personal Notes
arrow_drop_up
Next

Minimum increment/decrement to make array non-Increasing
Recommended Articles
Page :
Minimum increment/decrement operations required to make Median as X
02, Jul 20
Minimum increment/decrement operations required on Array to satisfy given conditions
19, Aug 20
Minimum increment and decrement by K of each pair elements required to make all array elements equal
31, Jan 21
Minimize increment or decrement operations to make given Array elements consecutive
12, Jan 22
Minimum number of increment/decrement operations such that array contains all elements from 1 to N
28, Nov 18
Minimize absolute difference between the smallest and largest array elements by minimum increment decrement operations
28, Jun 21
Minimum increment or decrement required to sort the array | Top-down Approach
09, Apr 20
Minimum increment/decrement to make array non-Increasing
20, May 18
Minimum Increment / decrement to make array elements equal
15, Nov 18
Count of suffix increment/decrement operations to construct a given array
10, Dec 17
Minimize increment/decrement of Array elements to make each modulo K equal
31, Jul 20
Making elements of two arrays same with minimum increment/decrement
05, May 18
Minimum decrement operations to make Array elements equal by only decreasing K each time
04, Feb 20
Increment odd positioned elements by 1 and decrement even positioned elements by 1 in an Array
01, Apr 19
Maximize frequency of an element by at most one increment or decrement of all array elements
08, Dec 20
Maximize frequency of an element by at most one increment or decrement of all array elements | Set 2
10, Nov 21
Minimize increment-decrement operation on adjacent elements to convert Array A to B
17, Aug 21
Minimum increment operations to make the array in increasing order
27, Oct 18
Minimum Increment operations to make Array unique
26, Nov 18
Minimum number of increment-other operations to make all array elements equal.
05, Oct 17
Minimum increment by k operations to make all elements equal
04, Mar 18
Minimum increment operations to make K elements equal
17, Sep 19
Minimize increment operations to make Array non-decreasing
27, Dec 21
Minimum range increment operations to Sort an array
03, Dec 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
KartikArora
@KartikArora
Vote for difficulty
Current difficulty :
Expert





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!