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

给定一个由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 。
  • 初始化两个变量，例如total和count ，分别为0和0 ，以分别存储所需的结果和达到avg的最小移动的前缀和。
  • 遍历给定数组arr []并执行以下步骤：
    • 将(arr [i] – avg)的值添加到count中。
    • 总的值更新为最大计数，总共，(ARR [Ⅰ] -平均值)的绝对值的。
• 完成上述步骤后，打印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)