# Make array elements equal in Minimum Steps

Given an array of N elements where the first element is a non zero positive number M, and the rest N – 1 elements are 0, the task is to calculate the minimum number of steps required to make the entire array equal while abiding by the following rules:

1. The ith element can be increased by one if and only if i-1th element is strictly greater than the ith element
2. If the ith element is being increased by one then the i+1th cannot be increased at the same time.(i.e consecutive elements cannot be increased at the same time)
3. Multiple elements can be incremented simultaneously in a single step.

Examples:

Input : N = 3, M = 4
Output : 8
Explanation:
array is 4 0 0
In 4 steps element at index 1 is increased, so the array becomes {4, 4, 0}. In the next 4 steps the element at index 3 is increased so array becomes {4, 4, 4}
Thus, 4 + 4 = 8 operations are required to make all the array elements equal

Input : N = 4, M = 4
Output : 9
Explanation:
The steps are shown in the flowchart given below
Refer to the flowchart given below.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution. Approach:
To maximise the Number of Increments per Step, more number of Unbalances are created (array[i]>array[i+1]),

Step 1, element 0 >element 1 so element 1 is incremented,

Step 2, element 1> element 2 so element 2 is incremented by 1

Step 3, element 0 > element 1 and element 2> element 3 so element 1 &3 are incremented by 1

Step 4, element 1 > element 2 element 3 > element 4 so element 2 & 4 are incremented

Step 5, element 0> element 1; element 2>element 3 ;element 4> element 5; so element 1, 3, &5 are incremented.
and so on…

Consider the following array,
5 0 0 0 0 0

1) 5 1 0 0 0 0
2) 5 1 1 0 0 0
3) 5 2 1 1 0 0
4) 5 2 2 1 1 0
5) 5 3 2 2 1 1
6) 5 3 3 2 2 1
7) 5 4 3 3 2 2
8) 5 4 4 3 3 2
9) 5 5 4 4 3 3
10) 5 5 5 4 4 3
11) 5 5 5 5 4 4
12) 5 5 5 5 5 4
13) 5 5 5 5 5 5

Notice that after an unbalance is created (i.e array[i]>array[i+1]) the element gets incremented by one in alternate steps. In step 1 element 1 gets incremented to 1, in step 2 element 2 gets incremented to 1, in step 3 element 3 gets incremented to 1, so in step n-1, n-1th element will become 1. After that n-1th element is increased by 1 on alternate steps until it reaches the value at element 0. Then the entire array becomes equal.

So the pattern followed by the last element is
(0, 0, 0.., 0) till (N – 4)th element becomes 1 which is n-4 steps
and after that,
(0, 0, 1, 1, 2, 2, 3, 3, 4, 4, … M – 1, M – 1, M) which is 2*m + 1 steps.

So the Final Result becomes (N – 3) + 2 * M

There are a few corner cases which need to be handled, viz. When N = 1, array has only a single element, so the number of steps required = 0. and When N = 2, number of steps required equal to M

## C++

 `// C++ program to make the array elements equal in minimum steps ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Returns the minumum steps required to make an array of N ` `// elements equal, where the first array element equals M ` `int` `steps(``int` `N, ``int` `M) ` `{ ` `    ``// Corner Case 1: When N = 1 ` `    ``if` `(N == 1) ` `        ``return` `0; ` ` `  `    ``// Corner Case 2: When N = 2 ` `    ``else` `if` `(N == 2) ``// corner case 2 ` `        ``return` `M; ` ` `  `    ``return` `2 * M + (N - 3); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 4, M = 4; ` `    ``cout << steps(N, M); ` `    ``return` `0; ` `} `

## Java

 `// Java program to make the array elements ` `// equal in minimum steps ` ` `  `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Returns the minumum steps required ` `    ``// to make an array of N elements equal, ` `    ``// where the first array element equals M ` `    ``static` `int` `steps(``int` `N, ``int` `M) ` `    ``{ ` `        ``// Corner Case 1: When N = 1 ` `        ``if` `(N == ``1``) ` `            ``return` `0``; ` `     `  `        ``// Corner Case 2: When N = 2 ` `        ``else` `if` `(N == ``2``) ``// corner case 2 ` `            ``return` `M; ` `     `  `        ``return` `2` `* M + (N - ``3``); ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``int` `N = ``4``, M = ``4``; ` `        ``System.out.print( steps(N, M)); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

## Python3

 `# Python program to make  ` `# the array elements equal ` `# in minimum steps ` ` `  `# Returns the minumum steps  ` `# required to make an array  ` `# of N elements equal, where ` `# the first array element  ` `# equals M ` `def` `steps(N, M): ` ` `  `    ``# Corner Case 1: When N = 1 ` `    ``if` `(N ``=``=` `1``): ` `        ``return` `0` ` `  `    ``# Corner Case 2: When N = 2 ` `    ``elif``(N ``=``=` `2``):  ` `        ``return` `M ` ` `  `    ``return` `2` `*` `M ``+` `(N ``-` `3``) ` ` `  `# Driver Code ` `N ``=` `4` `M ``=` `4` `print``(steps(N,M)) ` ` `  `# This code is contributed ` `# by Shivi_Aggarwal. `

## C#

 `// C# program to make the array  ` `// elements equal in minimum steps ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `    ``// Returns the minumum steps  ` `    ``// required to make an array  ` `    ``// of N elements equal, where  ` `    ``// the first array element  ` `    ``// equals M ` `    ``static` `int` `steps(``int` `N, ``int` `M) ` `    ``{ ` `        ``// Corner Case 1: When N = 1 ` `        ``if` `(N == 1) ` `             ``return` `0; ` `     `  `        ``// Corner Case 2: When N = 2 ` `        ``else` `if` `(N == 2) ``// corner case 2 ` `            ``return` `M; ` `     `  `        ``return` `2 * M + (N - 3); ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `Main ()  ` `    ``{ ` `        ``int` `N = 4, M = 4; ` `        ``Console.WriteLine(steps(N, M)); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

## PHP

 ` `

Output:

```9
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : vt_m, Shivi_Aggarwal, jit_t

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.