Related Articles

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

• Last Updated : 05 Aug, 2021

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`
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up