# Reduce the array to a single integer with the given operation

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

## Recommended Posts:

- Find single in an array of 2n+1 integer elements
- Reduce number to a single digit by subtracting adjacent digits repeatedly
- Reduce the array to atmost one element by the given operations
- Reduce every element of the array to it's half retaining the sum zero
- Reduce the array such that each element appears at most 2 times
- Reduce the array such that each element appears at most K times
- Minimizing array sum by applying XOR operation on all elements of the array
- Minimum steps required to reduce all the elements of the array to zero
- Minimum number of given operations required to reduce the array to 0 element
- Maximizing array sum with given operation
- Maximum possible array sum after performing the given operation
- Minimize the non-zero elements in the Array by given operation
- Sum of the updated array after performing the given operation
- Make the array non-decreasing with the given operation
- Minimum number of operations to convert array A to array B by adding an integer into a subarray
- Array element moved by k using single moves
- Move all zeroes to end of array | Set-2 (Using single traversal)
- Minimum possible sum of array elements after performing the given operation
- Minimum possible sum of array elements after performing the given operation
- Constant time range add operation on an 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.