📌  相关文章
📜  最小化数组元素的增量/减量,使每个模 K 相等

📅  最后修改于: 2021-10-27 07:56:59             🧑  作者: Mango

给定一个长度为N的数组arr[]和一个整数K 。在每个操作中,可以从数组中选择任何元素(比如arr[i] ),并且可以将其更改为arr[i] + 1arr[i] – 1 。任务是找到对数组执行所需的最少操作次数,以使数组模 K 的每个值保持不变。

例子:

方法:这个想法是使用散列来保留已获得的每个模的计数。

  • 现在迭代 i 的每个值,范围为 0 <= i < k,并找到使所有数字的模相等所需的运算次数。
  • 如果它小于获得的值比当前存储的值,则更新它。

下面是上述方法的实现:

C++
// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the minimum operations
// required to make the modulo of each
// element of the array equal to each other
int Find_min(set& diff_mod,
             map count_mod, int k)
{
    // Variable to store minimum
    // operation required
    int min_oprn = INT_MAX;
 
    // To store operation required to
    // make all modulo equal
    int oprn = 0;
 
    // Iterating through all
    // possible modulo value
    for (int x = 0; x < k; x++) {
        oprn = 0;
 
        // Iterating through all different
        // modulo obtained so far
        for (auto w : diff_mod) {
 
            // Calculating oprn required
            // to make all modulos equal
            // to x
            if (w != x) {
 
                if (w == 0) {
 
                    // Checking the operations
                    // that will cost less
                    oprn += min(x, k - x)
                            * count_mod[w];
                }
 
                else {
 
                    // Check operation that
                    // will cost less
                    oprn += min(
                                abs(x - w),
                                k + x - w)
                            * count_mod[w];
                }
            }
        }
 
        // Update the minimum
        // number of operations
        if (oprn < min_oprn)
            min_oprn = oprn;
    }
 
    // Returing the answer
    return min_oprn;
}
 
// Function to store different modulos
int Cal_min(int arr[], int n, int k)
{
    // Set to store all
    // different modulo
    set diff_mod;
 
    // Map to store count
    // of all different  modulo
    // obtained
    map count_mod;
 
    // Storing all different
    // modulo count
    for (int i = 0; i < n; i++) {
 
        // Insert into the set
        diff_mod.insert(arr[i] % k);
 
        // Increment count
        count_mod[arr[i] % k]++;
    }
 
    // Function call to return value of
    // min oprn required
    return Find_min(diff_mod, count_mod, k);
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 35, 48, 23, 52 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
    cout << Cal_min(arr, n, k);
    return 0;
}


Java
// Java program for the above approach
import java.util.*;
 
class GFG{
     
// Function to find the minimum operations
// required to make the modulo of each
// element of the array equal to each other
static int Find_min(HashSet diff_mod,
                    HashMap count_mod,
                    int k)
{
     
    // Variable to store minimum
    // operation required
    int min_oprn = Integer.MAX_VALUE;
 
    // To store operation required to
    // make all modulo equal
    int oprn = 0;
 
    // Iterating through all
    // possible modulo value
    for(int x = 0; x < k; x++)
    {
        oprn = 0;
 
        // Iterating through all different
        // modulo obtained so far
        for(int w : diff_mod)
        {
 
            // Calculating oprn required
            // to make all modulos equal
            // to x
            if (w != x)
            {
                if (w == 0)
                {
                     
                    // Checking the operations
                    // that will cost less
                    oprn += Math.min(x, k - x) *
                            count_mod.get(w);
                }
                else
                {
                     
                    // Check operation that
                    // will cost less
                    oprn += Math.min(Math.abs(x - w),
                                     k + x - w) *
                                     count_mod.get(w);
                }
            }
        }
 
        // Update the minimum
        // number of operations
        if (oprn < min_oprn)
            min_oprn = oprn;
    }
 
    // Returing the answer
    return min_oprn;
}
 
// Function to store different modulos
static int Cal_min(int arr[], int n, int k)
{
     
    // Set to store all
    // different modulo
    HashSet diff_mod = new HashSet<>();
 
    // Map to store count
    // of all different modulo
    // obtained
    HashMap count_mod = new HashMap<>();
 
    // Storing all different
    // modulo count
    for(int i = 0; i < n; i++)
    {
         
        // Insert into the set
        diff_mod.add(arr[i] % k);
 
        // Increment count
        count_mod.put(arr[i] % k,
        count_mod.getOrDefault(arr[i] % k, 0) + 1);
    }
 
    // Function call to return value of
    // min oprn required
    return Find_min(diff_mod, count_mod, k);
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 2, 35, 48, 23, 52 };
    int n = arr.length;
    int k = 3;
     
    System.out.print(Cal_min(arr, n, k));
}
}
 
// This code is contributed by jrishabh99


Python3
# Python3 program for
# the above approach
import sys
from collections import defaultdict
 
# Function to find the minimum operations
# required to make the modulo of each
# element of the array equal to each other
def Find_min(diff_mod,
             count_mod, k):
 
    # Variable to store minimum
    # operation required
    min_oprn = sys.maxsize
 
    # To store operation required to
    # make all modulo equal
    oprn = 0
 
    # Iterating through all
    # possible modulo value
    for x in range (k):
        oprn = 0
 
        # Iterating through all different
        # modulo obtained so far
        for w in diff_mod:
 
            # Calculating oprn required
            # to make all modulos equal
            # to x
            if (w != x):
 
                if (w == 0):
 
                    # Checking the operations
                    # that will cost less
                    oprn += (min(x, k - x) *
                             count_mod[w])
                
                else:
 
                    # Check operation that
                    # will cost less
                    oprn += (min(abs(x - w),
                                     k + x - w) *
                                     count_mod[w])
           
        # Update the minimum
        # number of operations
        if (oprn < min_oprn):
            min_oprn = oprn
    
    # Returing the answer
    return min_oprn
 
# Function to store different modulos
def Cal_min(arr,  n, k):
 
    # Set to store all
    # different modulo
    diff_mod = set([])
 
    # Map to store count
    # of all different  modulo
    # obtained
    count_mod = defaultdict (int)
 
    # Storing all different
    # modulo count
    for i in range (n):
 
        # Insert into the set
        diff_mod.add(arr[i] % k)
 
        # Increment count
        count_mod[arr[i] % k] += 1
    
    # Function call to return value of
    # min oprn required
    return Find_min(diff_mod, count_mod, k)
 
# Driver Code
if __name__ == "__main__": 
    arr = [2, 35, 48, 23, 52]
    n = len(arr)
    k = 3
    print( Cal_min(arr, n, k))
     
# This code is contributed by Chitranayal


C#
// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to find the minimum operations
// required to make the modulo of each
// element of the array equal to each other
static int Find_min(HashSet diff_mod,
                    Dictionary count_mod,
                    int k)
{
     
    // Variable to store minimum
    // operation required
    int min_oprn = int.MaxValue;
 
    // To store operation required to
    // make all modulo equal
    int oprn = 0;
 
    // Iterating through all
    // possible modulo value
    for(int x = 0; x < k; x++)
    {
        oprn = 0;
 
        // Iterating through all different
        // modulo obtained so far
        foreach(int w in diff_mod)
        {
 
            // Calculating oprn required
            // to make all modulos equal
            // to x
            if (w != x)
            {
                if (w == 0)
                {
                     
                    // Checking the operations
                    // that will cost less
                    oprn += Math.Min(x, k - x) *
                            count_mod[w];
                }
                else
                {
                     
                    // Check operation that
                    // will cost less
                    oprn += Math.Min(Math.Abs(x - w),
                                     k + x - w) *
                                     count_mod[w];
                }
            }
        }
 
        // Update the minimum
        // number of operations
        if (oprn < min_oprn)
            min_oprn = oprn;
    }
 
    // Returing the answer
    return min_oprn;
}
 
// Function to store different modulos
static int Cal_min(int []arr, int n, int k)
{
     
    // Set to store all
    // different modulo
    HashSet diff_mod = new HashSet();
 
    // Map to store count
    // of all different modulo
    // obtained
    Dictionary count_mod = new Dictionary();
 
    // Storing all different
    // modulo count
    for(int i = 0; i < n; i++)
    {
         
        // Insert into the set
        diff_mod.Add(arr[i] % k);
 
        // Increment count
        if(count_mod.ContainsKey((arr[i] % k)))
            count_mod[arr[i] % k] = count_mod[(arr[i] % k)]+1;
        else
            count_mod.Add(arr[i] % k, 1);
    }
 
    // Function call to return value of
    // min oprn required
    return Find_min(diff_mod, count_mod, k);
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 2, 35, 48, 23, 52 };
    int n = arr.Length;
    int k = 3;
     
    Console.Write(Cal_min(arr, n, k));
}
}
 
// This code is contributed by Amit Katiyar


Javascript


输出:
2

时间复杂度: O(N*K)