使数组元素相等的最小增量/减量

给定一个整数数组，其中$1 \leq A[i] \leq 10^{18}$ 。在一个操作中，您可以将任何元素增加/减少1。任务是找到对数组元素执行的最小操作，以使所有数组元素相等。

例子：

Input : A[] = { 1, 5, 7, 10 }
Output : 11
Increment 1 by 4, 5 by 0.
Decrement 7 by 2, 10 by 5.
New array A = { 5, 5, 5, 5 } with 
cost of operations = 4 + 0 + 2 + 5 = 11.

Input : A = { 10, 2, 20 }
Output : 18

方法：

1. 按升序对整数数组进行排序。
2. 现在，使所有元素等于最小成本。我们将必须使元素等于此排序数组的中间元素。因此，选择中间值，使其为K。

   注意：如果元素数量为偶数，我们将必须检查两个中间元素的成本，并采取最低限度的措施。

3. 如果A [i] ，则将元素递增K – A [i] 。
4. 如果A [i]> K ，则将元素减A [i] – K。
5. 更新执行的每个操作的成本。

下面是上述方法的实现：

C++

// C++ program to find minimum Increment or
// decrement to make array elements equal
#include 
using namespace std;
  
// Function to return minimum operations need
// to be make each element of array equal
int minCost(int A[], int n)
{
    // Initialize cost to 0
    int cost = 0;
  
    // Sort the array
    sort(A, A + n);
  
    // Middle element
    int K = A[n / 2];
  
    // Find Cost
    for (int i = 0; i < n; ++i)
        cost += abs(A[i] - K);
  
    // If n, is even. Take minimum of the
    // Cost obtained by considering both
    // middle elements
    if (n % 2 == 0) {
        int tempCost = 0;
  
        K = A[(n / 2) - 1];
  
        // Find cost again
        for (int i = 0; i < n; ++i)
            tempCost += abs(A[i] - K);
  
        // Take minimum of two cost
        cost = min(cost, tempCost);
    }
  
    // Return total cost
    return cost;
}
  
// Driver Code
int main()
{
    int A[] = { 1, 6, 7, 10 };
  
    int n = sizeof(A) / sizeof(A[0]);
  
    cout << minCost(A, n);
  
    return 0;
}

Java

// Java program to find minimum Increment or 
// decrement to make array elements equal 
import java.util.*;
class GfG { 
  
// Function to return minimum operations need 
// to be make each element of array equal 
static int minCost(int A[], int n) 
{ 
    // Initialize cost to 0 
    int cost = 0; 
  
    // Sort the array 
    Arrays.sort(A); 
  
    // Middle element 
    int K = A[n / 2]; 
  
    // Find Cost 
    for (int i = 0; i < n; ++i) 
        cost += Math.abs(A[i] - K); 
  
    // If n, is even. Take minimum of the 
    // Cost obtained by considering both 
    // middle elements 
    if (n % 2 == 0) { 
        int tempCost = 0; 
  
        K = A[(n / 2) - 1]; 
  
        // Find cost again 
        for (int i = 0; i < n; ++i) 
            tempCost += Math.abs(A[i] - K); 
  
        // Take minimum of two cost 
        cost = Math.min(cost, tempCost); 
    } 
  
    // Return total cost 
    return cost; 
} 
  
// Driver Code 
public static void main(String[] args) 
{ 
    int A[] = { 1, 6, 7, 10 }; 
  
    int n = A.length; 
  
    System.out.println(minCost(A, n)); 
}
}

Python3

# Python3 program to find minimum Increment or
# decrement to make array elements equal
      
# Function to return minimum operations need
# to be make each element of array equal
def minCost(A, n):
      
    # Initialize cost to 0
    cost = 0
      
    # Sort the array
    A.sort();
      
    # Middle element
    K = A[int(n / 2)]
      
    #Find Cost
    for i in range(0, n):
        cost = cost + abs(A[i] - K)
      
    # If n, is even. Take minimum of the
    # Cost obtained by considering both
    # middle elements
    if n % 2 == 0:
        tempCost = 0
        K = A[int(n / 2) - 1]
          
        # FInd cost again
        for i in range(0, n):
            tempCost = tempCost + abs(A[i] - K)
          
        # Take minimum of two cost
        cost = min(cost, tempCost)
          
    # Return total cost
    return cost
      
# Driver code
A = [1, 6, 7, 10]
n = len(A)
  
print(minCost(A, n))
          
# This code is contributed 
# by Shashank_Sharma

C#

// C# program to find minimum Increment or
// decrement to make array elements equal
using System;
  
class GFG {
      
// Function to return minimum operations need
// to be make each element of array equal
static int minCost(int []A, int n)
{
    // Initialize cost to 0
    int cost = 0;
  
    // Sort the array
    Array.Sort(A);
  
    // Middle element
    int K = A[n / 2];
  
    // Find Cost
    for (int i = 0; i < n; ++i)
        cost += Math.Abs(A[i] - K);
  
    // If n, is even. Take minimum of the
    // Cost obtained by considering both
    // middle elements
    if (n % 2 == 0) {
        int tempCost = 0;
  
        K = A[(n / 2) - 1];
  
        // Find cost again
        for (int i = 0; i < n; ++i)
            tempCost += Math.Abs(A[i] - K);
  
        // Take minimum of two cost
        cost = Math.Min(cost, tempCost);
    }
  
    // Return total cost
    return cost;
}
  
// Driver Code
public static void Main(String[] args)
{
    int []A = new int []{ 1, 6, 7, 10 };
  
    int n = A.Length;
  
    Console.WriteLine(minCost(A, n));
}
}

输出：

10

时间复杂度： O(N * log(N))

进一步的优化我们可以找到线性时间的中位数，并将时间复杂度降低到O(N)