 GFG App
Open App Browser
Continue

# Minimum increment/decrement to make array non-Increasing

Given an array a, your task is to convert it into a non-increasing form such that we can either increment or decrement the array value by 1 in the minimum changes possible.

Examples :

Input : a[] = {3, 1, 2, 1}
Output : 1
Explanation : We can convert the array into 3 1 1 1 by changing 3rd element of array i.e. 2  into its previous integer 1 in one step hence only one step is required.

Input : a[] = {3, 1, 5, 1}
Output : 4
Explanation : We need to decrease 5 to 1 to make array sorted in non-increasing order.

Input : a[] = {1, 5, 5, 5}
Output : 4
Explanation : We need to increase 1 to 5.

Brute-Force approach: We consider both possibilities for every element and find a minimum of two possibilities.

Efficient Approach Method 1 (Using Min-Heap):
Calculate the sum of absolute differences between the final array elements and the current array elements. Thus, the answer will be the sum of the difference between the ith element and the smallest element that occurred until then. For this, we can maintain a min-heap to find the smallest element encountered till then. In the min-priority queue, we will put the elements, and new elements are compared with the previous minimum. If the new minimum is found we will update it, this is done because each of the next elements which are coming should be smaller than the current minimum element found till now. Here, we calculate the difference so that we can get how much we have to change the current number so that it will be equal or less than previous numbers encountered. Lastly, the sum of all these differences will be our answer as this will give the final value up to which we have to change the elements.

Below is the implementation of the above approach:

## C++14

 `// CPP code to count the change required to` `// convert the array into non-increasing array` `#include ` `using` `namespace` `std;`   `int` `DecreasingArray(``int` `a[], ``int` `n)` `{` `    ``int` `sum = 0, dif = 0;`   `    ``// min heap` `    ``priority_queue<``int``, vector<``int``>, greater<``int``> > pq;`   `    ``// Here in the loop we will check that whether` `    ``// the top of priority queue is less than` `    ``// the upcoming array element. If yes then` `    ``// we calculate the difference. After that` `    ``// we will remove that element and push the` `    ``// current element in queue. And the sum` `    ``// is incremented by the value of difference` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(!pq.empty() && pq.top() < a[i]) {` `            ``dif = a[i] - pq.top();` `            ``sum += dif;`   `            ``// Removing that minimum element` `            ``// which does follow the decreasing` `            ``// property and replacing it with a[i]` `            ``// to maintain the condition` `            ``pq.pop();` `            ``pq.push(a[i]);` `        ``}`   `        ``// Push the current element as well` `        ``pq.push(a[i]);` `    ``}`   `    ``return` `sum;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `a[] = { 3, 1, 2, 1 };` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a);`   `    ``cout << DecreasingArray(a, n);`   `    ``return` `0;` `}`

## Java

 `// Java code to count the change required to ` `// convert the array into non-increasing array` `import` `java.util.PriorityQueue;`   `class` `GFG` `{` `    ``public` `static` `int` `DecreasingArray(``int` `a[], ``int` `n)` `    ``{` `        ``int` `sum = ``0``, dif = ``0``;`   `        ``PriorityQueue pq = ``new` `PriorityQueue<>();`   `        ``// Here in the loop we will` `        ``// check that whether the upcoming` `        ``// element of array is less than top` `        ``// of priority queue. If yes then we` `        ``// calculate the difference. After` `        ``// that we will remove that element` `        ``// and push the current element in` `        ``// queue. And the sum is incremented` `        ``// by the value of difference` `        ``for` `(``int` `i = ``0``; i < n; i++)` `        ``{` `            ``if` `(!pq.isEmpty() && pq.element() < a[i])` `            ``{` `                ``dif = a[i] - pq.element();` `                ``sum += dif;` `                ``pq.remove();` `                  ``pq.add(a[i]);` `            ``}` `            ``pq.add(a[i]);` `        ``}` `    `  `    ``return` `sum;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        `  `        ``int``[] a = {``3``, ``1``, ``2``, ``1``};` `        `  `        ``int` `n = a.length;`   `        ``System.out.println(DecreasingArray(a, n));` `    ``}` `}`   `// This Code is contributed by sanjeev2552`

## Python3

 `# Python3 code to count the change required to` `# convert the array into non-increasing array` `from` `queue ``import` `PriorityQueue `   `def` `DecreasingArray(a, n):` `    `  `    ``ss, dif ``=` `(``0``,``0``)` `    `  `    ``# min heap` `    ``pq ``=` `PriorityQueue()`   `    ``# Here in the loop we will` `    ``# check that whether the upcoming` `    ``# element of array is less than top` `    ``# of priority queue. If yes then we` `    ``# calculate the difference. After` `    ``# that we will remove that element` `    ``# and push the current element in` `    ``# queue. And the sum is incremented` `    ``# by the value of difference` `    ``for` `i ``in` `range``(n):` `        ``tmp ``=` `0` `        `  `        ``if` `not` `pq.empty():` `            ``tmp ``=` `pq.get()` `            ``pq.put(tmp)` `        `  `        ``if` `not` `pq.empty() ``and` `tmp < a[i]:` `            ``dif ``=` `a[i] ``-` `tmp` `            ``ss ``+``=` `dif` `            ``pq.get()` `            ``pq.put(a[i])` `        `  `        ``pq.put(a[i])` `      `  `    ``return` `ss` `    `  `# Driver code    ` `if` `__name__``=``=``"__main__"``:` `    `  `    ``a ``=` `[ ``3``, ``1``, ``2``, ``1` `]` `    ``n ``=` `len``(a)` ` `  `    ``print``(DecreasingArray(a, n))` `    `  `# This code is contributed by rutvik_56`

## C#

 `// C# code to count the change required to` `// convert the array into non-increasing array` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG` `{` `    ``static` `int` `DecreasingArray(``int``[] a, ``int` `n)` `    ``{` `        ``int` `sum = 0, dif = 0;` `     `  `        ``// min heap` `        ``List<``int``> pq = ``new` `List<``int``>();` `     `  `        ``// Here in the loop we will` `        ``// check that whether the upcoming` `        ``// element of array is less than top` `        ``// of priority queue. If yes then we` `        ``// calculate the difference. After` `        ``// that we will remove that element` `        ``// and push the current element in` `        ``// queue. And the sum is incremented` `        ``// by the value of difference` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{` `            ``if` `(pq.Count > 0 && pq < a[i])` `            ``{` `                ``dif = a[i] - pq;` `                ``sum += dif;` `                ``pq.RemoveAt(0);` `                  ``pq.Add(a[i]);` `            ``}` `            ``pq.Add(a[i]);` `            ``pq.Sort();` `        ``}` `     `  `        ``return` `sum;` `    ``}   `   `  ``// Driver code` `  ``static` `void` `Main()` `  ``{` `    ``int``[] a = { 3, 1, 2, 1 };` `    ``int` `n = a.Length;` ` `  `    ``Console.Write(DecreasingArray(a, n)); ` `  ``}` `}`   `// This code is contributed by divyeshrabadiya07.`

## Javascript

 ``

Output

`1`

Complexity Analysis:

• Time Complexity: O(n log(n))
• Auxiliary Space: O(n)

Method 2: Using Max-Heap:

Traverse in reverse order in the given array and keep maintaining the increasing property. If any element is smaller than the maximum of existing elements till that index then, we need to make some decrement operation on that maximum element so that it also follows the increasing property from back traversal and add the required operation in the answer.

Implementation:

## C++

 `// CPP code to count the change required to` `// convert the array into non-increasing array` `#include ` `using` `namespace` `std;`   `int` `DecreasingArray(``int` `arr[], ``int` `n)` `{` `    ``int` `ans = 0;`   `    ``// max heap` `    ``priority_queue<``int``> pq;`   `    ``// Here in the loop we will` `    ``// check that whether the top` `    ``// of priority queue is greater than the upcoming array` `    ``// element. If yes then we calculate the difference.` `    ``// After that we will remove that element and push the` `    ``// current element in queue. And the sum is incremented` `    ``// by the value of difference`   `    ``for` `(``int` `i = n - 1; i >= 0; i--) {` `        ``if` `(!pq.empty() and pq.top() > arr[i]) {` `            ``ans += ``abs``(arr[i] - pq.top());` `            ``pq.pop();` `            ``pq.push(arr[i]);` `        ``}` `        ``pq.push(arr[i]);` `    ``}` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `a[] = { 3, 1, 2, 1 };` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a);`   `    ``cout << DecreasingArray(a, n);`   `    ``return` `0;` `}`

## Java

 `// Java code to count the change required to` `// convert the array into non-increasing array` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {` `    ``public` `static` `int` `DecreasingArray(``int` `arr[], ``int` `n)` `    ``{` `        ``int` `ans = ``0``;`   `        ``// max heap` `        ``PriorityQueue pq = ``new` `PriorityQueue<>(` `            ``Collections.reverseOrder());`   `        ``// Here in the loop we will` `        ``// check that whether the top` `        ``// of priority queue is greater than the upcoming` `        ``// array element. If yes then we calculate the` `        ``// difference. After that we will remove that` `        ``// element and push the current element in queue.` `        ``// And the sum is incremented by the value of` `        ``// difference`   `        ``for` `(``int` `i = n - ``1``; i >= ``0``; i--) {` `            ``if` `(!pq.isEmpty() && pq.peek() > arr[i]) {` `                ``ans += Math.abs(arr[i] - pq.peek());` `                ``pq.poll();` `                ``pq.add(arr[i]);` `            ``}` `            ``pq.add(arr[i]);` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `a[] = { ``3``, ``1``, ``2``, ``1` `};` `        ``int` `n = a.length;`   `        ``System.out.print(DecreasingArray(a, n));` `    ``}` `}`   `// This code is contributed by Rohit Pradhan`

## Python3

 `# Python code to count the change required to` `# convert the array into non-increasing array` `def` `DecreasingArray(arr, n):` `    ``ans ``=` `0` `    `  `    ``# max heap` `    ``pq ``=` `[]` `    `  `    ``# Here in the loop we will` `    ``# check that whether the top` `    ``# of priority queue is greater than the upcoming array` `    ``# element. If yes then we calculate the difference.` `    ``# After that we will remove that element and push the` `    ``# current element in queue. And the sum is incremented` `    ``# by the value of difference` `    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):` `        ``if` `pq ``and` `pq[``0``] > arr[i]:` `            ``ans ``+``=` `abs``(arr[i] ``-` `pq[``0``])` `            ``pq.pop(``0``)` `            ``pq.insert(``0``, arr[i])` `        ``pq.insert(``0``, arr[i])` `    ``return` `ans` `    `  `# Driver Code` `a ``=` `[``3``, ``1``, ``2``, ``1``]` `n ``=` `len``(a)`   `print``(DecreasingArray(a, n))`   `# This code is contributed by phasing17.`

## C#

 `// C# code to count the change required to` `// convert the array into non-increasing array` `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``public` `static` `int` `DecreasingArray(``int``[] arr, ``int` `n)` `  ``{` `    ``int` `ans = 0;`   `    ``// max heap` `    ``SortedSet<``int``> pq = ``new` `SortedSet<``int``>();`   `    ``// Here in the loop we will` `    ``// check that whether the top` `    ``// of priority queue is greater than the upcoming` `    ``// array element. If yes then we calculate the` `    ``// difference. After that we will remove that` `    ``// element and push the current element in queue.` `    ``// And the sum is incremented by the value of` `    ``// difference` `    ``for` `(``int` `i = n - 1; i >= 0; i--) {` `      ``if` `(pq.Count > 0 && pq.Max > arr[i]) {` `        ``ans += Math.Abs(arr[i] - pq.Max);` `        ``pq.Remove(pq.Max);` `        ``pq.Add(arr[i]);` `      ``}` `      ``pq.Add(arr[i]);` `    ``}` `    ``return` `ans;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``int``[] a = { 3, 1, 2, 1 };` `    ``int` `n = a.Length;`   `    ``Console.WriteLine(DecreasingArray(a, n));` `  ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Javascript

 `// JS code to count the change required to` `// convert the array into non-increasing array` `function` `DecreasingArray(arr, n) {` `    ``let ans = 0;`   `    ``// max heap` `    ``let pq = [];`   `    ``// Here in the loop we will` `    ``// check that whether the top` `    ``// of priority queue is greater than the upcoming array` `    ``// element. If yes then we calculate the difference.` `    ``// After that we will remove that element and push the` `    ``// current element in queue. And the sum is incremented` `    ``// by the value of difference`   `    ``for` `(let i = n - 1; i >= 0; i--) {` `        ``if` `(pq.length != 0 && pq > arr[i]) {` `            ``ans += Math.abs(arr[i] - pq);` `            ``pq.pop();` `            ``pq.unshift(arr[i]);` `        ``}` `        ``pq.unshift(arr[i]);` `    ``}` `    ``return` `ans;` `}`   `// Driver Code` `let a = [3, 1, 2, 1];` `let n = a.length;`   `console.log(DecreasingArray(a, n));`   `// This code is contributed by ishankhandelwals.`

Output

`1`

Complexity Analysis:

• Time Complexity: O(n log(n))
• Auxiliary Space: O(n)

My Personal Notes arrow_drop_up