最小化减法，然后是使所有数组元素相等所需的相邻元素的增量

给定一个由N 个正整数组成的数组arr[] ，任务是通过重复从任意数量的数组元素中减去 1并同时将其添加到相邻元素之一，使所有数组元素相等。如果不能使所有数组元素相等，则打印“-1” 。否则，打印所需的最小操作数。

例子：

Input: arr[] = {1, 0, 5}
Output: 3
Explanation:
Operation 1: Subtract arr[2](= 5) by 1 and add it to arr[1](= 0). Therefore, the array arr[] modifies to {1, 1, 4}.
Operation 2: Subtract arr[2](= 4) by 1 and add it to arr[1](= 1). Therefore, the array arr[] modifies to {1, 2, 3}.
Operation 3: Subtract arr[2](= 3) and arr[1](= 2) by 1 and add it to arr[1](= 1) and arr[2](= 2) respectively. Therefore, the array arr[] modifies to {2, 2, 2}.

Therefore, the minimum number of operations required is 3.

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

方法：根据以下观察可以解决给定的问题：

• 当且仅当所有数组元素的值等于数组的平均值时，才能使所有数组元素相等。
• 由于一次只能从数组元素中减去1 ，因此最小移动次数是数组前缀和的最大值或使每个元素等于数组平均值所需的移动次数。

请按照以下步骤解决问题：

• 计算数组arr[]元素的总和，比如S 。
• 如果总和S不能被N整除，则打印“-1” 。
• 否则，执行以下操作：
  • 将数组元素的平均值存储在一个变量中，比如avg 。
  • 用0初始化两个变量，比如total和count ，分别存储所需的结果和最小移动的前缀和，以实现avg 。
  • 遍历给定的数组arr[]并执行以下步骤：
    • 将(arr[i] – avg)的值添加到计数中。
    • 将total的值更新为count 、 total 、 (arr[i] – avg)绝对值的最大值。
• 完成上述步骤后，打印total的值作为所需的最小运算结果。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the minimum number
// of moves required to make all array
// elements equal
int findMinMoves(int arr[], int N)
{
    // Store the total sum of the array
    int sum = 0;
 
    // Calculate total sum of the array
    for (int i = 0; i < N; i++)
        sum += arr[i];
 
    // If the sum is not divisible
    // by N, then print "-1"
    if (sum % N != 0)
        return -1;
 
    // Stores the average
    int avg = sum / N;
 
    // Stores the count
    // of operations
    int total = 0;
 
    int needCount = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
        // Update number of moves
        // required to make current
        // element equal to avg
        needCount += (arr[i] - avg);
 
        // Update the overall count
        total
            = max(max(abs(needCount),
                      arr[i] - avg),
                  total);
    }
 
    // Return the minimum
    // operations required
    return total;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 0, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << findMinMoves(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
 
// Function to find the minimum number
// of moves required to make all array
// elements equal
static int findMinMoves(int[] arr, int N)
{
     
    // Store the total sum of the array
    int sum = 0;
 
    // Calculate total sum of the array
    for(int i = 0; i < N; i++)
        sum += arr[i];
 
    // If the sum is not divisible
    // by N, then print "-1"
    if (sum % N != 0)
        return -1;
 
    // Stores the average
    int avg = sum / N;
 
    // Stores the count
    // of operations
    int total = 0;
 
    int needCount = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // Update number of moves
        // required to make current
        // element equal to avg
        needCount += (arr[i] - avg);
 
        // Update the overall count
        total = Math.max(
            Math.max(Math.abs(needCount),
                     arr[i] - avg), total);
    }
 
    // Return the minimum
    // operations required
    return total;
}
 
// Driver Code
public static void main(String[] args)
{
    int[] arr = { 1, 0, 5 };
    int N = arr.length;
     
    System.out.println(findMinMoves(arr, N));
}
}
 
// This code is contributed by sanjoy_62

Python3

# Python3 program for the above approach
 
# Function to find the minimum number
# of moves required to make all array
# elements equal
def findMinMoves(arr, N):
   
    # Store the total sum of the array
    sum = 0
 
    # Calculate total sum of the array
    for i in range(N):
        sum += arr[i]
 
    # If the sum is not divisible
    # by N, then print "-1"
    if(sum % N != 0):
        return -1
 
    # Stores the average
    avg = sum // N
 
    # Stores the count
    # of operations
    total = 0
    needCount = 0
 
    # Traverse the array arr[]
    for i in range(N):
       
        # Update number of moves
        # required to make current
        # element equal to avg
        needCount += (arr[i] - avg)
 
        # Update the overall count
        total = max(max(abs(needCount), arr[i] - avg), total)
 
    # Return the minimum
    # operations required
    return total
 
# Driver Code
if __name__ == '__main__':
    arr =  [1, 0, 5]
    N =  len(arr)
    print(findMinMoves(arr, N))
 
    # This code is contributed by bgangwar59.

C#

// C# program for the above approach
using System;
 
class GFG{
     
// Function to find the minimum number
// of moves required to make all array
// elements equal
static int findMinMoves(int[] arr, int N)
{
     
    // Store the total sum of the array
    int sum = 0;
 
    // Calculate total sum of the array
    for(int i = 0; i < N; i++)
        sum += arr[i];
 
    // If the sum is not divisible
    // by N, then print "-1"
    if (sum % N != 0)
        return -1;
 
    // Stores the average
    int avg = sum / N;
 
    // Stores the count
    // of operations
    int total = 0;
 
    int needCount = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // Update number of moves
        // required to make current
        // element equal to avg
        needCount += (arr[i] - avg);
 
        // Update the overall count
        total = Math.Max(
            Math.Max(Math.Abs(needCount),
                     arr[i] - avg), total);
    }
 
    // Return the minimum
    // operations required
    return total;
}
 
// Driver Code
public static void Main()
{
    int[] arr = { 1, 0, 5 };
    int N = arr.Length;
     
    Console.Write(findMinMoves(arr, N));
}
}
 
// This code is contributed by ukasp

Javascript

 
// Javascript program for the above approach
 
// Function to find the minimum number
// of moves required to make all array
// elements equal
function findMinMoves(arr, N)
{
     
    // Store the total sum of the array
    let sum = 0;
 
    // Calculate total sum of the array
    for(let i = 0; i < N; i++)
        sum += arr[i];
 
    // If the sum is not divisible
    // by N, then print "-1"
    if (sum % N != 0)
        return -1;
 
    // Stores the average
    let avg = sum / N;
 
    // Stores the count
    // of operations
    let total = 0;
 
    let needCount = 0;
 
    // Traverse the array arr[]
    for(let i = 0; i < N; i++)
    {
         
        // Update number of moves
        // required to make current
        // element equal to avg
        needCount += (arr[i] - avg);
 
        // Update the overall count
        total = Math.max(Math.max(
                Math.abs(needCount),
                arr[i] - avg), total);
    }
 
    // Return the minimum
    // operations required
    return total;
}
 
// Driver Code
let arr = [ 1, 0, 5 ];
let N = arr.length;
 
document.write(findMinMoves(arr, N))
 
// This code is contributed by Hritik
 

输出：

3

时间复杂度： O(N)
辅助空间： O(1)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live