通过将数组元素减少到最小次数的一半，使所有数组元素相等

给定一个由N 个整数组成的数组arr[] ，任务是通过将A _i转换为A _i / 2来最小化使所有数组元素相等所需的操作次数。

例子：

Input: arr[] = {3, 1, 1, 3}
Output: 2
Explanation: 
Reducing A₀ to A₀ / 2 modifies arr[] to {1, 1, 1, 3}. 
Reducing A₃ to A₃ / 2 modifies arr[] to {1, 1, 1, 1}. 
Therefore, all array elements are equal, Hence, the minimum operations required is 2.

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

方法：解决这个问题的想法是使用贪心方法。以下是步骤：

• 初始化一个辅助 Map，比如mp。
• 遍历数组，对于每个数组元素，将元素除以2直到它减少到1 ，并将结果数字存储在 Map 中。
• 遍历地图并找到频率等于N的最大元素，例如mx 。
• 再次遍历数组，对于每个元素，将元素除以2，直到它等于mx并递增计数。
• 打印计数作为所需操作的最小数量。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find minimum number of operations
int minOperations(int arr[], int N)
{
    // Initialize map
    map mp;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
        int res = arr[i];
 
        // Divide current array
        // element until it reduces to 1
        while (res) {
 
            mp[res]++;
            res /= 2;
        }
    }
 
    int mx = 1;
    // Traverse the map
    for (auto it : mp) {
        // Find the maximum element
        // having frequency equal to N
        if (it.second == N) {
            mx = it.first;
        }
    }
 
    // Stores the minimum number
    // of operations required
    int ans = 0;
 
    for (int i = 0; i < N; i++) {
        int res = arr[i];
 
        // Count operations required to
        // convert current element to mx
        while (res != mx) {
 
            ans++;
 
            res /= 2;
        }
    }
 
    // Print the answer
    cout << ans;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 3, 1, 1, 3 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    minOperations(arr, N);
}

Java

// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
 
class GFG{
 
  // Function to find minimum number of operations
  static void minOperations(int[] arr, int N)
  {
    // Initialize map
    HashMap mp = new HashMap();
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
      int res = arr[i];
 
      // Divide current array
      // element until it reduces to 1
      if (mp.containsKey(res))
        mp.put(res, mp.get(res) + 1);
      else
        mp.put(res, 1);
 
      res /= 2;
    }   
    int mx = 1;
 
    for(Map.Entry it : mp.entrySet())
    {
 
      // Find the maximum element
      // having frequency equal to N
      if (it.getValue() == N)
      {
        mx = it.getKey();
      }
    }
 
    // Stores the minimum number
    // of operations required
    int ans = 0;
 
    for (int i = 0; i < N; i++)
    {
      int res = arr[i];
 
      // Count operations required to
      // convert current element to mx
      while (res != mx)
      {
        ans++;
        res /= 2;
      }
    }
 
    // Print the answer
    System.out.println(ans);
  }      
 
  // Driver Code
  public static void main(String[] args)
  {
    // Given array
    int arr[] = { 3, 1, 1, 3 };
 
    // Size of the array
    int N = arr.length;
    minOperations(arr, N);
  }
}
 
// This code is contributed by code_hunt.

Python3

# Python program for the above approach
# Function to find minimum number of operations
def minOperations(arr, N):
   
  # Initialize map
  mp = {}
   
  # Traverse the array
  for i in range(N):
    res = arr[i]
     
    # Divide current array
    # element until it reduces to 1
    while (res):
      if res in mp:
        mp[res] += 1
      else:
        mp[res] = 1
      res //= 2
  mx = 1
   
  # Traverse the map
  for it in mp:
     
    # Find the maximum element
    # having frequency equal to N
    if (mp[it] == N):
      mx = it
       
  # Stores the minimum number
  # of operations required
  ans = 0
  for i in range(N):
    res = arr[i]
     
    # Count operations required to
    # convert current element to mx
    while (res != mx):
      ans += 1
      res //= 2
       
  # Print the answer
  print(ans)
 
# Driver Code
# Given array
arr = [ 3, 1, 1, 3 ]
 
# Size of the array
N = len(arr)
minOperations(arr, N)
 
# This code is contributed by rohitsingh07052.

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG {
     
    // Function to find minimum number of operations
    static void minOperations(int[] arr, int N)
    {
        // Initialize map
        Dictionary mp = new Dictionary();
      
        // Traverse the array
        for (int i = 0; i < N; i++) {
            int res = arr[i];
      
            // Divide current array
            // element until it reduces to 1
            while (res > 0) {
                if(mp.ContainsKey(res))
                {
                    mp[res]++;
                }
                else{
                    mp[res] = 1;
                }
                res /= 2;
            }
        }   
        int mx = 1;
        
        foreach(KeyValuePair it in mp)
        {
           
            // Find the maximum element
            // having frequency equal to N
            if (it.Value == N)
            {
                mx = it.Key;
            }
        }
      
        // Stores the minimum number
        // of operations required
        int ans = 0;
      
        for (int i = 0; i < N; i++)
        {
            int res = arr[i];
      
            // Count operations required to
            // convert current element to mx
            while (res != mx)
            {
                ans++;
                res /= 2;
            }
        }
      
        // Print the answer
        Console.Write(ans);
    }
 
  // Driver code
  static void Main()
  {
     
    // Given array
    int[] arr = { 3, 1, 1, 3 };
  
    // Size of the array
    int N = arr.Length;
  
    minOperations(arr, N);
  }
}
 
// This code is contributed by divyesh072019.

Javascript

 
// Javascript program for the above approach
 
// Function to find minimum number of operations
function minOperations(arr, N)
{
    // Initialize map
    var mp = new Map();
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
        var res = arr[i];
 
        // Divide current array
        // element until it reduces to 1
        while (res) {
 
            if(mp.has(res))
            {
                mp.set(res, mp.get(res)+1);
            }
            else
            {
                mp.set(res, 1);
            }
            res = parseInt(res/2);
        }
    }
 
    var mx = 1;
    // Traverse the map
    mp.forEach((value, key) => {
        // Find the maximum element
        // having frequency equal to N
        if (value == N) {
            mx = key;
        }
    });
 
    // Stores the minimum number
    // of operations required
    var ans = 0;
 
    for (var i = 0; i < N; i++) {
        var res = arr[i];
 
        // Count operations required to
        // convert current element to mx
        while (res != mx) {
 
            ans++;
 
            res = parseInt(res/2);
        }
    }
 
    // Print the answer
    document.write( ans);
}
 
// Driver Code
 
// Given array
var arr = [3, 1, 1, 3];
 
// Size of the array
var N = arr.length;
minOperations(arr, N);
 

输出：

2

时间复杂度： O(N * log(max(arr[i]))
辅助空间： O(N)

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