Open In App

# 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:

• Pick the two largest element from the array and remove these element. If the elements are unequal then insert the absolute difference of the elements into the array.
• Perform the above operations until array has 1 or no element in it. If the array has only one element left then print that element, else print “-1”.

Examples:

Input: arr[] = { 3, 5, 2, 7 }
Output:
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.
4. If the heap has only one element then print that element.
5. Else print “-1”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``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);` `    ``// Function Call``    ``final_element(arr, n);``    ``return` `0;``}`

## Java

 `// 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 heap = ``new``    ``PriorityQueue(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`

## Python3

 `# 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`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `// Function to print the remaining element``static` `void` `final_element(``int``[] arr, ``int` `n)``{``    ` `    ``// Priority queue can be used``    ``// to construct max-heap``    ``List<``int``> heap = ``new` `List<``int``>();``  ` `    ``// Insert all element of arr[]``    ``// into priority queue``    ``for``(``int` `i = 0; i < n; i++)``        ``heap.Add(arr[i]);``  ` `    ``// Perform operation until heap``    ``// size becomes 0 or 1``    ``while` `(heap.Count > 1)``    ``{``        ` `        ``// Remove largest element``        ``heap.Sort();``        ``heap.Reverse();``        ``int` `X = heap;``        ``heap.RemoveAt(0);``  ` `        ``// Remove 2nd largest element``        ``int` `Y = heap;``        ``heap.RemoveAt(0);``  ` `        ``// If extracted element``        ``// are not equal``        ``if` `(X != Y)``        ``{``            ` `            ``// Find X - Y and push``            ``// it to heap``            ``int` `diff = Math.Abs(X - Y);``            ``heap.Add(diff);``        ``}``    ``}``  ` `    ``// If heap size is 1, then``    ``// print the remaining element``    ``if` `(heap.Count == 1)``    ``{``        ``heap.Sort();``        ``heap.Reverse();``        ``Console.Write(heap);``    ``}``  ` `    ``// Else print "-1"``    ``else``    ``{``        ``Console.Write(-1);``    ``}``}` `// Driver code``static` `void` `Main()``{``    ` `    ``// Given array arr[]``    ``int``[] arr = { 3, 5, 2, 7 };``    ` `    ``// Size of array arr[]``    ``int` `n = arr.Length;``    ` `    ``// Function Call``    ``final_element(arr, n);``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`1`

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