Last element remaining by deleting two largest elements and replacing by their absolute difference if they are unequal

Given an array arr[] of N elements, the task is to perform the following operation:

Examples:

Input: arr[] = { 3, 5, 2, 7 }
Output: 1
Explanation:
The two largest elements are 7 and 5. Discard them. Since both are not equal, insert 7 – 5 = 2 into the array. Hence, arr[] = { 3, 2, 2 }
The two largest elements are 3 and 2. Discard them. Since both are not equal, insert 3 – 2 = 1 into the array. Hence, arr[] = { 1, 2 }
The two largest elements are 2 and 1. Discard them. Since both are not equal, insert 2 – 1 = 1 into the array. Hence, arr[] = { 1 }
The only element left is 1. Print the value of the only element left.

Input: arr[] = { 3, 3 }
Output: -1
Explanation:
The two largest elements are 3 and 3. Discard them. Now the array has no elements. So, print -1.

Approach: To solve the above problem we will use Priority Queue Data Structure. Below are the steps:



  1. Insert all the array elements in the Priority Queue.
  2. As priority queue is based on the implementation of Max-Heap. Therefore removing element from it gives the maximum element.
  3. Till the size of priority queue is not less than 2, remove two elements(say X & Y) from it and do the following:
    • If X and Y are not same then insert the absolute value of X and Y into the priority queue.
    • Else return to step 3.
  4. If the heap has only one element then print that element.
  5. Else print “-1”.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to print the remaining element
int final_element(int arr[], int n)
{
  
    // Priority queue can be used
    // to construct max-heap
    priority_queue<int> heap;
  
    // Insert all element of arr[]
    // into priority queue
    for (int i = 0; i < n; i++)
        heap.push(arr[i]);
  
    // Perform operation until heap
    // size becomes 0 or 1
    while (heap.size() > 1) {
  
        // Remove largest element
        int X = heap.top();
        heap.pop();
  
        // Remove 2nd largest element
        int Y = heap.top();
        heap.pop();
  
        // If extracted element
        // are not equal
        if (X != Y) {
  
            // Find X - Y and push
            // it to heap
            int diff = abs(X - Y);
            heap.push(diff);
        }
    }
  
    // If heap size is 1, then
    // print the remaining element
    if (heap.size() == 1) {
  
        cout << heap.top();
    }
  
    // Else print "-1"
    else {
        cout << "-1";
    }
}
  
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 3, 5, 2, 7 };
  
    // Size of array arr[]
    int n = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    final_element(arr, n);
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach 
import java.io.*; 
import java.util.Collections;
import java.util.*;
  
class GFG{ 
      
// Function to print the remaining element     
static public int final_element(Integer[] arr, int n)
{
    if(arr == null)
    {
        return 0;
    }
      
    // Priority queue can be used 
    // to construct max-heap 
    PriorityQueue<Integer> heap = new
    PriorityQueue<Integer>(Collections.reverseOrder()); 
      
    // Insert all element of arr[] 
    // into priority queue 
    for(int i = 0; i < n; i++)
    {
       heap.offer(arr[i]);
    }
      
    // Perform operation until heap 
    // size becomes 0 or 1 
    while (heap.size() > 1)
    {
          
        // Remove largest element 
        int X = heap.poll();
          
        // Remove 2nd largest element 
        int Y = heap.poll();
          
        // If extracted element 
        // are not equal 
        if (X != Y)
        {
            // Find X - Y and push 
            // it to heap 
            int diff = Math.abs(X - Y);
            heap.offer(diff);
        }
    }
      
    // If heap size is 1, then 
    // print the remaining element 
    // Else print "-1" 
    return heap.size() == 1 ? heap.poll() : -1;
}
  
// Driver code
public static void main (String[] args) 
    // Given array arr[] 
    Integer arr[] = new Integer[] { 3, 5, 2, 7};
      
    // Size of array arr[] 
    int n = arr.length;
      
    // Function Call 
    System.out.println(final_element(arr, n));  
}
}
  
// This code is contributed by deepika_sharma
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach 
from queue import PriorityQueue
  
# Function to print the remaining element
def final_element(arr, n):
      
    # Priority queue can be used
    # to construct max-heap
    heap = PriorityQueue()
      
    # Insert all element of
    # arr[] into priority queue.
    # Default priority queue in Python 
    # is min-heap so use -1*arr[i]
    for i in range(n):
        heap.put(-1 * arr[i])
      
    # Perform operation until heap
    # size becomes 0 or 1
    while (heap.qsize() > 1):
  
        # Remove largest element
        X = -1 * heap.get()
  
        # Remove 2nd largest element
        Y = -1 * heap.get()
  
        # If extracted elements
        # are not equal
        if (X != Y):
  
            # Find X - Y and push
            # it to heap
            diff = abs(X - Y)
            heap.put(-1 * diff)
  
    # If heap size is 1, then 
    # print the remaining element
    if (heap.qsize() == 1):
        print(-1 * heap.get())
  
    # Else print "-1"
    else:
        print("-1")
  
# Driver Code
if __name__ == '__main__':
      
    # Given array arr[]
    arr = [ 3, 5, 2, 7 ]
  
    # Size of array arr[]
    n = len(arr)
  
    # Function call
    final_element(arr, n)
  
# This code is contributed by himanshu77
chevron_right

Output:
1

Time Complexity: O(N*log(N))
Auxiliary Space Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :