Given an array **arr[]** of **N** integers from **1** to **N**. The task is to perform the following operations **N – 1** times.

- Select two elements
**X**and**Y**from the array. - Delete the chosen elements from the array.
- Add
**X**in the array.^{2}+ Y^{2}

After performing above operations **N – 1** times only one integer will be left in the array. The task is to print the maximum possible value of that integer.

**Examples:**

Input:N = 3

Output:170

Initial array: arr[] = {1, 2, 3}

Choose 2 and 3 and the array becomes arr[] = {1, 13}

Performing the operation again by choosing the only two elements left,

the array becomes arr[] = {170} which is the maximum possible value.

Input:N = 4

Output:395642

**Approach:** To maximize the value of final integer we have to maximize the value of **(X ^{2} + Y^{2})**. So each time we have to choose the maximum two values from the array. Store all integers in a priority queue. Each time pop top 2 elements and push the result of

**(X**in the priority queue. The last remaining element will be the maximum possible value of the required integer.

^{2}+ Y^{2})Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` `#define ll long long int ` ` ` `// Function to return the maximum ` `// integer after performing the operations ` `int` `reduceOne(` `int` `N) ` `{ ` ` ` `priority_queue<ll> pq; ` ` ` ` ` `// Initialize priority queue with ` ` ` `// 1 to N ` ` ` `for` `(` `int` `i = 1; i <= N; i++) ` ` ` `pq.push(i); ` ` ` ` ` `// Perform the operations while ` ` ` `// there are at least 2 elements ` ` ` `while` `(pq.size() > 1) { ` ` ` ` ` `// Get the maximum and ` ` ` `// the second maximum ` ` ` `ll x = pq.top(); ` ` ` `pq.pop(); ` ` ` `ll y = pq.top(); ` ` ` `pq.pop(); ` ` ` ` ` `// Push (x^2 + y^2) ` ` ` `pq.push(x * x + y * y); ` ` ` `} ` ` ` ` ` `// Return the only element left ` ` ` `return` `pq.top(); ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `N = 3; ` ` ` ` ` `cout << reduceOne(N); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation of the approach ` `import` `java.util.*; ` ` ` `class` `GFG ` `{ ` ` ` ` ` `// Function to return the maximum ` ` ` `// integer after performing the operations ` ` ` `static` `long` `reduceOne(` `int` `N) ` ` ` `{ ` ` ` `// To create Max-Heap ` ` ` `PriorityQueue<Long> pq = ` `new` ` ` `PriorityQueue<Long>(Collections.reverseOrder()); ` ` ` ` ` `// Initialize priority queue with ` ` ` `// 1 to N ` ` ` `for` `(` `long` `i = ` `1` `; i <= N; i++) ` ` ` `pq.add(i); ` ` ` ` ` `// Perform the operations while ` ` ` `// there are at least 2 elements ` ` ` `while` `(pq.size() > ` `1` `) ` ` ` `{ ` ` ` ` ` `// Get the maximum and ` ` ` `// the second maximum ` ` ` `long` `x = pq.poll(); ` ` ` `long` `y = pq.poll(); ` ` ` ` ` `// Push (x^2 + y^2) ` ` ` `pq.add(x * x + y * y); ` ` ` `} ` ` ` ` ` `// Return the only element left ` ` ` `return` `pq.peek(); ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `N = ` `3` `; ` ` ` `System.out.println(reduceOne(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by ` `// sanjeev2552 ` |

*chevron_right*

*filter_none*

**Output:**

170

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:

- Reduce a given Binary Array to a single element by removal of Triplets
- Minimize Cost to reduce the Array to a single element by given operations
- Reduce array to a single element by repeatedly removing an element from any increasing pair
- Reduce array to a single element by repeatedly replacing adjacent unequal pairs with their maximum
- Reduce number to a single digit by subtracting adjacent digits repeatedly
- Find single in an array of 2n+1 integer elements
- Minimum number of given operations required to reduce the array to 0 element
- Reduce the array to atmost one element by the given operations
- Minimum replacement of pairs by their LCM required to reduce given array to its LCM
- Maximizing array sum with given operation
- Make all elements of an array equal with the given operation
- Minimum possible sum of array elements after performing the given operation
- Find the number of different numbers in the array after applying the given operation q times
- Make the array non-decreasing with the given operation
- Sum of the updated array after performing the given operation
- Maximum possible array sum after performing the given operation
- Minimum possible sum of array elements after performing the given operation
- Minimize the non-zero elements in the Array by given operation
- Maximize count of distinct elements possible in an Array from the given operation
- Minimizing array sum by applying XOR operation on all elements of the array

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.