# Minimum number of operations required to make an array non-decreasing by adding 2^i to a subset in every i-th operation

• Last Updated : 13 Jul, 2021

Given an array arr[] consisting of N integers, the task is to find the minimum number of operations required to make the array non-decreasing by choosing any subset of array arr[] and adding 2i to all elements of the subset in ith step.

Examples:

Input: arr[ ] = {1, 7, 6, 5}
Output: 2
Explanation:
One way to make the array non-decreasing is:

1. Increment arr[1] and arr[3] by 20. Thereafter, the array modifies to {2, 7, 6, 6}.
2. Increment arr[2] and arr[3] by 21. Thereafter, the array modifies to {2, 7, 8, 8}.

Therefore, two operations are needed to make the array non-decreasing. Also, it is the minimum count of operations.

Input: arr[ ] = {1, 2, 3, 4, 5}
Output: 0

Approach: The given problem can be solved based on the following observations:

Supposing A[] as the original array and B[] as the final, then:

1. There will be only one way to make the final non-decreasing array, because there is no more than a single way to make a specific amount of addition to a number. Therefore, the task will be to minimize the max(B1−A1, B2−A2, …, Bn−An), as smaller differences lead to the use of shorter time to make the array non-decreasing.
2.  B[] is optimal when B[i] is the maximum value between B1, B2, …, B[i]−1 and A[i] because for each position i,  B[i]−A[i] should be as small as possible and B[i-1] ≤ B[i] and A[i] ≤ B[i].
3. If X operations are performed, then any array element can be increased by any integer in the range [0, 2X-1].

Follow the steps below to solve the problem:

• Initialize a variable, say val as 0, to store the maximum difference between the final array elements and the original array elements at the same indices.
• Initialize another variable, say mx as INT_MIN, to store the maximum of the prefix of the array.
• Traverse the array, arr[] using variable i and in each iteration update mx to max(mx, arr[i]) and val to max(val, mx – arr[i]).
• The highest power of 2, smaller than an integer, val, and then store it in a variable, say res.
• Finally, after completing the above steps, print the value of res as the answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the minimum number``// of steps required to make arr non-``// decreasing``int` `countMinSteps(``int` `arr[], ``int` `N)``{``    ``// Stores differences``    ``int` `val = 0;` `    ``// Stores the max number``    ``int` `mx = INT_MIN;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``int` `curr = arr[i];` `        ``// Update mx``        ``mx = max(mx, curr);` `        ``// Update val``        ``val = max(val, mx - curr);``    ``}` `    ``// Stores the result``    ``long` `long` `res = 0;` `    ``// Iterate until 2^res-1 is less``    ``// than val``    ``while` `((1LL << res) - 1 < val) {``        ``++res;``    ``}` `    ``// Return the answer``    ``return` `res;``}` `// Driver Code``int` `main()``{``    ``// Given input``    ``int` `arr[] = { 1, 7, 6, 5 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``cout << countMinSteps(arr, N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG``{``  ` `    ``// Function to count the minimum number``    ``// of steps required to make arr non-``    ``// decreasing``    ``static` `int` `countMinSteps(``int` `arr[], ``int` `N)``    ``{``      ` `        ``// Stores differences``        ``int` `val = ``0``;` `        ``// Stores the max number``        ``int` `mx = Integer.MIN_VALUE;` `        ``// Traverse the array arr[]``        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``int` `curr = arr[i];` `            ``// Update mx``            ``mx = Math.max(mx, curr);` `            ``// Update val``            ``val = Math.max(val, mx - curr);``        ``}` `        ``// Stores the result``        ``long` `res = ``0``;` `        ``// Iterate until 2^res-1 is less``        ``// than val``        ``while` `((``1` `<< res) - ``1` `< val) {``            ``++res;``        ``}` `        ``// Return the answer``        ``return` `(``int``)res;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``      ` `        ``// Given input``        ``int` `arr[] = { ``1``, ``7``, ``6``, ``5` `};``        ``int` `N = arr.length;` `        ``// Function call``        ``System.out.println(countMinSteps(arr, N));``      ` `    ``}``}` `// This code is contributed by Potta Lokesh`

## Python3

 `# Python3 program for the above approach` `# Function to count the minimum number``# of steps required to make arr non-``# decreasing``def` `countMinSteps(arr, N):``    ` `    ``# Stores differences``    ``val ``=` `0` `    ``# Stores the max number``    ``mx ``=` `-``10``*``*``9` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(N):``        ``curr ``=` `arr[i]` `        ``# Update mx``        ``mx ``=` `max``(mx, curr)` `        ``# Update val``        ``val ``=` `max``(val, mx ``-` `curr)` `    ``# Stores the result``    ``res ``=` `0` `    ``# Iterate until 2^res-1 is less``    ``# than val``    ``while` `((``1` `<< res) ``-` `1` `< val):``        ``res ``+``=` `1` `    ``# Return the answer``    ``return` `res` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given input``    ``arr ``=` `[ ``1``, ``7``, ``6``, ``5` `]``    ``N ``=` `len``(arr)` `    ``# Function call``    ``print``(countMinSteps(arr, N))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to count the minimum number``// of steps required to make arr non-``// decreasing``static` `int` `countMinSteps(``int` `[]arr, ``int` `N)``{``    ``// Stores differences``    ``int` `val = 0;` `    ``// Stores the max number``    ``int` `mx = Int32.MinValue;` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``int` `curr = arr[i];` `        ``// Update mx``        ``mx = Math.Max(mx, curr);` `        ``// Update val``        ``val = Math.Max(val, mx - curr);``    ``}` `    ``// Stores the result``    ``int` `res = 0;` `    ``// Iterate until 2^res-1 is less``    ``// than val``    ``while` `((1 << res) - 1 < val) {``        ``++res;``    ``}` `    ``// Return the answer``    ``return` `res;``}` `// Driver Code``public` `static` `void` `Main()``{``    ``// Given input``    ``int` `[]arr = { 1, 7, 6, 5 };``    ``int` `N = arr.Length;` `    ``// Function call``    ``Console.Write(countMinSteps(arr, N));``}``}` `// This code is contributed by SURENDRA_GANGWAR.`

## Javascript

 ``

Output

`2`

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

My Personal Notes arrow_drop_up