Minimize remaining array element by removing pairs and replacing them with their average

Given an array arr[] of size N, the task is to find the smallest possible remaining array element by repeatedly removing a pair, say (arr[i], arr[j]) from the array and inserting the Ceil value of their average.

Examples:

Input: arr[] = { 1, 2, 3 } 
Output: 2
Explanation: 
Removing the pair (arr[1], arr[2]) from arr[] and inserting (arr[1] + arr[2] + 1) / 2 into arr[] modifies arr[] to { 1, 2 }. 
Removing the pair (arr[0], arr[1]) from arr[] and inserting (arr[0] + arr[1] + 1) / 2 into arr[] modifies arr[] to { 2 }. 
Therefore, the required output is 2.

Input: arr[] = { 30, 16, 40 } 
Output: 26 
Explanation: 
Removing the pair (arr[0], arr[2]) from arr[] and inserting (arr[0] + arr[2] + 1) / 2 into arr[] modifies arr[] to { 16, 35 } . 
Removing the pair (arr[0], arr[1]) from arr[] and inserting (arr[0] + arr[1] + 1) / 2 into arr[] modifies arr[] to { 26 } . 
Therefore, the required output is 26.

Approach: The problem can be solved using Greedy technique. The idea is to repeatedly remove the maximum and the second-maximum array element and insert their average. Finally, print the smallest element left in the array.

• Initialize a priority_queue, say PQ, to store the array elements such that the largest element is always present at the top of PQ.
• Traverse the array and store all the array elements in PQ.
• Iterate over the elements of the priority_queue while count of elements in the priority_queue is greater than 1. In every iteration, pop the top two elements from PQ and insert the Ceil value of their average.
• Finally, print the element left in PQ.

Below is the implementation of the above approach:

// C++ program to implement
// the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the smallest element
// left in the array by removing pairs
// and inserting their average
int findSmallestNumLeft(int arr[], int N)
{
    // Stores array elements such that the
    // largest element present at top of PQ
    priority_queue<int> PQ;

    // Traverse the array
    for (int i = 0; i < N; i++) {

        // Insert arr[i] into PQ
        PQ.push(arr[i]);
    }

    // Iterate over elements of PQ while count
    // of elements in PQ greater than 1
    while (PQ.size() > 1) {

        // Stores largest element of PQ
        int top1 = PQ.top();

        // Pop the largest element of PQ
        PQ.pop();

        // Stores largest element of PQ
        int top2 = PQ.top();

        // Pop the largest element of PQ
        PQ.pop();

        // Insert the ceil value of average
        // of top1 and top2
        PQ.push((top1 + top2 + 1) / 2);
    }

    return PQ.top();
}

// Driver Code
int main()
{
    int arr[] = { 30, 16, 40 };
    int N = sizeof(arr)
            / sizeof(arr[0]);

    cout << findSmallestNumLeft(
        arr, N);

    return 0;
}

// Java program to implement
// the above approach
import java.util.PriorityQueue;

class GFG{

// Function to find the smallest element
// left in the array by removing pairs
// and inserting their average
static int findSmallestNumLeft(int arr[], int N)
{
  
    // Stores array elements such that the
    // largest element present at top of PQ
    PriorityQueue<Integer> PQ = new PriorityQueue<Integer>((a,b)->b-a);

    // Traverse the array
    for (int i = 0; i < N; i++) 
    {

        // Insert arr[i] into PQ
        PQ.add(arr[i]);
    }

    // Iterate over elements of PQ while count
    // of elements in PQ greater than 1
    while (PQ.size() > 1) 
    {

        // Stores largest element of PQ
        int top1 = PQ.peek();

        // Pop the largest element of PQ
        PQ.remove();

        // Stores largest element of PQ
        int top2 = PQ.peek();

        // Pop the largest element of PQ
        PQ.remove();

        // Insert the ceil value of average
        // of top1 and top2
        PQ.add((top1 + top2 + 1) / 2);
    }

    return PQ.peek();
}

// Driver Code
public static void main(String[] args)
{
    int arr[] = { 30, 16, 40 };
    int N = arr.length;

    System.out.print(findSmallestNumLeft(
        arr, N));

}
}

// This code is contributed by Amit Katiyar 

# Python3 program to implement
# the above approach

# Function to find the smallest element
# left in the array by removing pairs
# and inserting their average
def findSmallestNumLeft(arr, N):
    
    # Stores array elements such that the
    # largest element present at top of PQ
    PQ = []

    # Traverse the array
    for i in range(N):
        
        # Insert arr[i] into PQ
        PQ.append(arr[i])

    # Iterate over elements of PQ while count
    # of elements in PQ greater than 1
    PQ = sorted(PQ)

    while (len(PQ) > 1):

        # Stores largest element of PQ
        top1 = PQ[-1]

        # Pop the largest element of PQ
        del PQ[-1]

        # Stores largest element of PQ
        top2 = PQ[-1]

        # Pop the largest element of PQ
        del PQ[-1]

        # Insert the ceil value of average
        # of top1 and top2
        PQ.append((top1 + top2 + 1) // 2)
        PQ = sorted(PQ)

    return PQ[-1]

# Driver Code
if __name__ == '__main__':
    
    arr = [ 30, 16, 40 ]
    N = len(arr)

    print (findSmallestNumLeft(arr, N))

# This code is contributed by mohit kumar 29

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GfG 
{ 
    // Function to find the smallest element
    // left in the array by removing pairs
    // and inserting their average
    static int findSmallestNumLeft(int[] arr, int N)
    {
        // Stores array elements such that the
        // largest element present at top of PQ
        List<int> PQ = new List<int>();
     
        // Traverse the array
        for (int i = 0; i < N; i++) {
     
            // Insert arr[i] into PQ
            PQ.Add(arr[i]);
        }
        
        PQ.Sort();
        PQ.Reverse();
        
        // Iterate over elements of PQ while count
        // of elements in PQ greater than 1
        while (PQ.Count > 1) {
     
            // Stores largest element of PQ
            int top1 = PQ[0];
     
            // Pop the largest element of PQ
            PQ.RemoveAt(0);
     
            // Stores largest element of PQ
            int top2 = PQ[0];
     
            // Pop the largest element of PQ
            PQ.RemoveAt(0);
     
            // Insert the ceil value of average
            // of top1 and top2
            PQ.Add((top1 + top2 + 1) / 2);
            
            PQ.Sort();
            PQ.Reverse();
        }
     
        return PQ[0];
    }

  // Driver code
    public static void Main() 
    { 
        int[] arr = { 30, 16, 40 };
        int N = arr.Length;
     
        Console.Write(findSmallestNumLeft(arr, N));
    } 
} 

// This code is contributed by divyeshrabadiya07.

<script>
// Javascript program to implement
// the above approach

// Function to find the smallest element
// left in the array by removing pairs
// and inserting their average
function  findSmallestNumLeft(arr, N)
{

    // Stores array elements such that the
    // largest element present at top of PQ
    let PQ = [];
 
    // Traverse the array
    for (let i = 0; i < N; i++)
    {
 
        // Insert arr[i] into PQ
        PQ.push(arr[i]);
    }
    
    PQ.sort(function(a,b){return b-a;});
 
    // Iterate over elements of PQ while count
    // of elements in PQ greater than 1
    while (PQ.length > 1)
    {
 
        // Stores largest element of PQ
        let top1 = PQ[0];
 
        // Pop the largest element of PQ
        PQ.shift();
 
        // Stores largest element of PQ
        let top2 = PQ[0];
 
        // Pop the largest element of PQ
        PQ.shift();
 
        // Insert the ceil value of average
        // of top1 and top2
        PQ.push(Math.floor((top1 + top2 + 1) / 2));
        PQ.sort(function(a,b){return b-a;});
    }
 
    return PQ[0];
}

// Driver Code
let arr = [ 30, 16, 40];
let N = arr.length;
document.write(findSmallestNumLeft(
        arr, N));

// This code is contributed by unknown2108
</script>

26

Time Complexity: O(N*logN), as we are using a loop to traverse N times and priority queue operation will take logN time.

Auxiliary Space: O(N), as we are using extra space for priority queue.