Minimize the max of Array by breaking array elements at most K times

// C# code to implement the approach
using System;
class GFG {

  // Function to find the minimum of maximum
  static int minimizeMaxElement(int[] arr, int K)
  {
    // Initialize a variable start = 1 and
    // end = maximum possible answer.
    int start = 1;

    int max = 0;

    for (int i = 0; i < arr.Length; i++) {
      if (arr[i] > max) {
        max = arr[i];
      }
    }

    int end = max;

    // Initialize a variable result which
    // will store the answer
    int result = -1;

    // Do while start <= end
    while (start <= end) {

      // Calculate mid = (start + end) / 2;
      int mid = (start + end) >> 1;

      // Calculate maximum number of
      // operation required to make
      // every element less than or
      // equal to mid.
      double operation = 0;

      // Iterate over the given array
      for (int i = 0; i < arr.Length; i++) {

        // Check if current element is
        // greater than mid, If true,
        // then calculate the operation
        // required to make this element
        // less than or equals to mid
        if (arr[i] > mid) {
          operation
            += Math.Ceiling((float)arr[i] / mid)
            - 1;
        }
      }

      // Check if total operation
      // required to make every element
      // less than or equal to mid is
      // greater less than equal to K
      // If true, update the result and
      // move the end to mid - 1
      if (operation <= K) {
        result = mid;
        end = mid - 1;
      }
      else {
        start = mid + 1;
      }
    }

    // Return the result.
    return result;
  }

  // Driver code
  public static void Main()
  {
    int[] arr = { 2, 4, 8, 2 };
    int K = 4;

    // Functions call
    Console.WriteLine(minimizeMaxElement(arr, K));
  }
}

// This code is contributed by Samim Hossain Mondal.

using System;
using System.Collections.Generic;
using System.Linq;

namespace minimizeMaxElement {
class Program {
    static void Main(string[] args)
    {
        List<int> arr = new List<int>{ 9 };
        int K;

        arr = new List<int>{ 2, 4, 8, 2 };
        K = 4;

        Console.WriteLine(MinimizeMaxElement(arr, K));
    }

    // Function to reduce the maximum element in array to 1
    // through the K operations
    static int MinimizeMaxElement(List<int> arr, int K)
    {
        // Create a priority queue
        PriorityQueue<int> pq = new PriorityQueue<int>(arr);
        int max_element = pq.Peek();

        // While K is not 0
        while (K-- > 0) {
            // Pop the top element from the priority queue
            int element = pq.Pop();

            // Calculate the half of the element
            int half = element / 2;

            // Push the half and the difference of the
            // element and half to the priority queue
            pq.Push(half);
            pq.Push(element - half);

            // Update the maximum element
            max_element = pq.Peek();

            // If the maximum element is 1, break the loop
            if (max_element <= 1)
                break;
        }

        // Return the maximum element
        return max_element;
    }
}

// Generic Priority Queue class
public class PriorityQueue<T> where T : IComparable<T> {
    List<T> data;

    // Constructor
    public PriorityQueue() { this.data = new List<T>(); }

    // Overloaded constructor
    public PriorityQueue(IEnumerable<T> collection)
    {
        this.data = new List<T>(collection);
        for (int i = (data.Count / 2) - 1; i >= 0; i--)
            HeapifyDown(i);
    }

    // Function to get the size of the priority queue
    public int Count() { return data.Count; }

    // Function to check if the priority queue is empty
    public bool IsEmpty() { return Count() == 0; }

    // Function to get the top element of the priority queue
    public T Peek()
    {
        if (IsEmpty())
            throw new Exception("Priority queue is empty.");

        return data[0];
    }

    // Function to pop the top element from the priority
    // queue
    public T Pop()
    {
        if (IsEmpty())
            throw new Exception("Priority queue is empty.");

        T element = Peek();
        Swap(0, Count() - 1);
        data.RemoveAt(Count() - 1);
        HeapifyDown(0);

        return element;
    }

    // Function to push an element to the priority queue
    public void Push(T item)
    {
        data.Add(item);
        HeapifyUp(Count() - 1);
    }

    // Function to heapify up
    private void HeapifyUp(int index)
    {
        if (index == 0)
            return;
        int parentIndex = (index - 1) / 2;
        if (data[index].CompareTo(data[parentIndex]) > 0) {
            Swap(index, parentIndex);
            HeapifyUp(parentIndex);
        }
    }

    // Function to heapify down
    private void HeapifyDown(int index)
    {
        int leftIndex = (2 * index) + 1;
        int rightIndex = (2 * index) + 2;
        int largestIndex = index;

        if (leftIndex < Count()
            && data[leftIndex].CompareTo(data[largestIndex])
                   > 0)
            largestIndex = leftIndex;

        if (rightIndex < Count()
            && data[rightIndex].CompareTo(
                   data[largestIndex])
                   > 0)
            largestIndex = rightIndex;

        if (largestIndex != index) {
            Swap(index, largestIndex);
            HeapifyDown(largestIndex);
        }
    }

    // Function to swap two elements
    private void Swap(int firstIndex, int secondIndex)
    {
        T temp = data[firstIndex];
        data[firstIndex] = data[secondIndex];
        data[secondIndex] = temp;
    }
}
}