在最小步长中使数组元素相等

给定一个包含N 个元素的数组，其中第一个元素是非零正数M ，其余 N – 1 个元素为 0，任务是计算使整个数组相等所需的最小步骤数，同时遵守以下条件规则：
1.第i^个元素可以加1当且仅当第i-1^个元素严格大于第i个元素
2. 如果第i^个元素加1，则不能同时增加^第i+1^个。（即不能同时增加连续元素）
3. 多个元素可以在一个步骤中同时递增。
例子：

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.

编程需要懂一点英语

输出流程图

方法：
为了最大化每步的增量数，创建更多数量的不平衡（array[i]>array[i+1]），
第1步，元素 0 > 元素 1，因此元素 1 递增，
第2步，元素 1> 元素 2 所以元素 2 增加 1
第3步，元素 0 > 元素 1 和元素 2> 元素 3，因此元素 1 &3 加 1
第4步，元素 1 > 元素 2 元素 3 > 元素 4 因此元素 2 和 4 递增
第五步，元素0>元素1；元素2>元素3；元素4>元素5；所以元素 1、3、&5 递增。
等等…
考虑以下数组，
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
请注意，在创建不平衡后（即数组[i]>数组[i+1]），元素以交替的步骤递增1。在步骤 1 中元素 1 增加到 1，在步骤 2 中元素 2 增加到 1，在步骤 3 中元素 3 增加到 1，所以在步骤 n-1 中，第 n-1^个元素将变为 1。之后 n-^第1^个元素以交替的步骤增加 1，直到它达到元素 0 处的值。然后整个数组变得相等。
所以最后一个元素后面的模式是
(0, 0, 0.., 0)直到第 (N – 4)^个元素变为 1，即n-4 步
在那之后，
(0, 0, 1, 1, 2, 2, 3, 3, 4, 4, … M – 1, M – 1, M)即2*m + 1 步。
所以最终结果变成(N – 3) + 2 * M
有一些极端情况需要处理，即。当N = 1 时，数组只有一个元素，因此所需的步数 = 0。当N = 2 时，所需的步数等于 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

Javascript

输出：

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。