📜  在给定阵列上最多进行K个拆分,以最大可能地减少最大阵列元素

📅  最后修改于: 2021-04-17 19:10:22             🧑  作者: Mango

给定一个由N个正整数和一个正整数K组成的数组arr [] ,任务是通过将最多K个数组元素拆分为两个等于其值的数字,以最小化数组中存在的最大元素。

例子:

方法:可以根据以下观察结果解决给定问题:

  • 如果通过执行最多K次操作, X可以成为数组arr []中的最大元素,则存在某个值K(K> X) ,也可以是数组arr []中存在的最大元素 通过最多对数组元素进行K个拆分。
  • 如果通过执行最多K次运算, X不能成为数组A []中的最大元素,则存在某个值K(K ,通过执行以下操作,它也不能成为数组arr []中的最大元素数组元素的大多数K个拆分。
  • 因此,我们的想法是使用二进制搜索来查找[1, INT_MAX ]范围内的值,该值可以是最多K个分割后的可能最大值。

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

  • 初始化两个变量,例如lowhigh分别1数组arr []中最大元素 分别。
  • 迭代直到low小于high并执行以下步骤:
    • 找到范围[low,high]的中间值,作为mid =(low + high)/ 2
    • 初始化一个变量,例如count ,以存储使最大元素等于mid所需的数组元素拆分的最大数目。
    • 遍历给定的数组arr []并将count的值更新为(arr [i] – 1)/ mid以计算所需的分割数。
    • 如果count的值最多为K ,则将high的值更新为mid
    • 否则,将low的值更新为(mid +1)
  • 完成上述步骤后,将high的值打印为所获得的数组中存在的结果最大元素。

下面是上述方法的实现:

C++
// C++ program for the above approach
#include 
using namespace std;
 
// Function to check if all array
// elements can be reduced to at
// most mid by at most K splits
int possible(int A[], int N,
             int mid, int K)
{
    // Stores the number
    // of splits required
    int count = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
        // Update count
        count += (A[i] - 1) / mid;
    }
 
    // If possible, return true.
    // Otherwise return false
    return count <= K;
}
 
// Function to find the minimum possible
// value of maximum array element that
// can be obtained by at most K splits
int minimumMaximum(int A[], int N, int K)
{
    // Set lower and upper limits
    int lo = 1;
    int hi = *max_element(A, A + N);
    int mid;
 
    // Perform Binary Search
    while (lo < hi) {
 
        // Calculate mid
        mid = (lo + hi) / 2;
 
        // Check if all array elements
        // can be reduced to at most
        // mid value by at most K splits
        if (possible(A, N, mid, K)) {
 
            // Update the value of hi
            hi = mid;
        }
 
        // Otherwise
        else {
 
            // Update the value of lo
            lo = mid + 1;
        }
    }
 
    // Return the minimized maximum
    // element in the array
    return hi;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 4, 8, 2 };
    int K = 4;
    int N = sizeof(arr) / sizeof(arr[0]);
 
    cout << minimumMaximum(arr, N, K);
 
    return 0;
}


Java
// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to check if all array
// elements can be reduced to at
// most mid by at most K splits
static boolean possible(int A[], int N,
                        int mid, int K)
{
     
    // Stores the number
    // of splits required
    int count = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // Update count
        count += (A[i] - 1) / mid;
    }
 
    // If possible, return true.
    // Otherwise return false
    return count <= K;
}
 
// Function to find the minimum possible
// value of maximum array element that
// can be obtained by at most K splits
static int minimumMaximum(int A[], int N, int K)
{
     
    // Set lower and upper limits
    int lo = 1;
    Arrays.sort(A);
     
    int hi = A[N - 1];
    int mid;
 
    // Perform Binary Search
    while (lo < hi)
    {
         
        // Calculate mid
        mid = (lo + hi) / 2;
 
        // Check if all array elements
        // can be reduced to at most
        // mid value by at most K splits
        if (possible(A, N, mid, K))
        {
             
            // Update the value of hi
            hi = mid;
        }
 
        // Otherwise
        else
        {
             
            // Update the value of lo
            lo = mid + 1;
        }
    }
 
    // Return the minimized maximum
    // element in the array
    return hi;
}
 
// Driver Code
public static void main (String[] args)
{
    int arr[] = { 2, 4, 8, 2 };
    int K = 4;
    int N = arr.length;
 
    System.out.println(minimumMaximum(arr, N, K));
}
}
 
// This code is contributed by AnkThon


Python3
# Python3 program for the above approach
 
# Function to check if all array
# elements can be reduced to at
# most mid by at most K splits
def possible(A, N, mid, K):
     
    # Stores the number
    # of splits required
    count = 0
 
    # Traverse the array arr[]
    for i in range(N):
         
        # Update count
        count += (A[i] - 1) // mid
 
    # If possible, return true.
    # Otherwise return false
    return count <= K
 
# Function to find the minimum possible
# value of maximum array element that
# can be obtained by at most K splits
def minimumMaximum(A, N, K):
     
    # Set lower and upper limits
    lo = 1
    hi = max(A)
 
    # Perform Binary Search
    while (lo < hi):
         
        # Calculate mid
        mid = (lo + hi) // 2
 
        # Check if all array elements
        # can be reduced to at most
        # mid value by at most K splits
        if (possible(A, N, mid, K)):
             
            # Update the value of hi
            hi = mid
 
        # Otherwise
        else:
             
            # Update the value of lo
            lo = mid + 1
 
    # Return the minimized maximum
    # element in the array
    return hi
 
# Driver Code
if __name__ == '__main__':
     
    arr =  [ 2, 4, 8, 2 ]
    K = 4
    N = len(arr)
 
    print(minimumMaximum(arr, N, K))
     
# This code is contributed by ipg2016107


C#
// C# program for the above approach
using System;
 
class GFG{
 
// Function to check if all array
// elements can be reduced to at
// most mid by at most K splits
static bool possible(int[] A, int N,
                     int mid, int K)
{
     
    // Stores the number
    // of splits required
    int count = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < N; i++)
    {
         
        // Update count
        count += (A[i] - 1) / mid;
    }
 
    // If possible, return true.
    // Otherwise return false
    return count <= K;
}
 
// Function to find the minimum possible
// value of maximum array element that
// can be obtained by at most K splits
static int minimumMaximum(int[] A, int N, int K)
{
     
    // Set lower and upper limits
    int lo = 1;
    Array.Sort(A);
 
    int hi = A[N - 1];
    int mid;
 
    // Perform Binary Search
    while (lo < hi)
    {
         
        // Calculate mid
        mid = (lo + hi) / 2;
 
        // Check if all array elements
        // can be reduced to at most
        // mid value by at most K splits
        if (possible(A, N, mid, K))
        {
             
            // Update the value of hi
            hi = mid;
        }
 
        // Otherwise
        else
        {
             
            // Update the value of lo
            lo = mid + 1;
        }
    }
 
    // Return the minimized maximum
    // element in the array
    return hi;
}
 
// Driver Code
public static void Main(string[] args)
{
    int[] arr = { 2, 4, 8, 2 };
    int K = 4;
    int N = arr.Length;
 
    Console.WriteLine(minimumMaximum(arr, N, K));
}
}
 
// This code is contributed by ukasp


输出:
2

时间复杂度: O(N * log M),其中M是数组最大元素
辅助空间: O(1)