Open In App

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

1. Select two elements X and Y from the array.
2. Delete the chosen elements from the array.
3. Add X2 + Y2in the array.

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
Explanation: 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 (X2 + Y2). 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 (X2 + Y2) in the priority queue. The last remaining element will be the maximum possible value of the required integer.

Algorithm:

Step 1: Start
Step 2: Create a static function names reduceOne of long return type which take an integer N as input.
Step 3: Create a priority_queue of type long long int
Step 4: Now with the help of for loop initialize the priority queue from 1 to n.
Step 5: Loop while the size of priority_queue is greater than 1
Get the maximum element x from priority_queue and remove it
Get the second top element y from priority_queue and remove it
Step 6: Now calculate the value of x^2 + y^2 and add it to the priority queue
Step 7: Return the element left in the priority queue
Step 8: End

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define ll long long int` `// Function to return the maximum``// integer after performing the operations``int` `reduceOne(``int` `N)``{``    ``priority_queue 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;``}`

## 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 pq = ``new``        ``PriorityQueue(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`

## Python3

 `# Python3 implementation of the approach` `from` `heapq ``import` `heappop, heappush, heapify` `# Function to return the maximum``# integer after performing the operations``def` `reduceOne(N) :``    ``pq ``=` `[]``    ` `    ``# Initialize priority queue with``    ``# 1 to N``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``pq.append(i)``      ` `    ``# Used to implement max heap``    ``for` `i ``in` `range``(``0``, N):``        ``pq[i] ``=` `-``1``*``pq[i];``    ``heapify(pq)``    ` `    ``# Perform the operations while``    ``# there are at least 2 elements``    ``while``(``len``(pq) > ``1``) :``    ` `        ``# Get the maximum and``        ``# the second maximum``        ``x ``=` `heappop(pq)``        ``y ``=` `heappop(pq)``    ` `        ``# Push (x^2 + y^2)``        ``heappush(pq, ``-``1` `*` `(x ``*` `x ``+` `y ``*` `y))``    ` `    ``# Return the only element left``    ``return` `-``1``*``heappop(pq)``    ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `3``    ``print``(reduceOne(N))` `# This code is contributed by divyeshrabadiya07.`

## Javascript

 `function` `reduceOne(N)``    ``{``        ``// To create Max-Heap``        ``let pq = [];` `        ``// Initialize priority queue with``        ``// 1 to N``        ``for` `(let i = 1; i <= N; i++){``            ``pq.push(i);``        ``}``         ` `         ``pq.sort();` `        ``// Perform the operations while``        ``// there are at least 2 elements``        ``while` `(pq.length > 1)``        ``{` `            ``// Get the maximum and``            ``// the second maximum``            ``let x = pq.pop();``            ``let y = pq.pop();` `            ``// Push (x^2 + y^2)``            ``pq.push((x * x) +(y * y));``        ``}` `        ``// Return the only element left``        ``return` `pq.pop();``    ``}` `        ``let N = 3;``        ``console.log(reduceOne(N));` `// This code is contributed by utkarshshirode02`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program``{``    ``static` `int` `reduceOne(``int` `N)``    ``{``        ``// To create Max-Heap``        ``var` `pq = ``new` `List<``int``>();` `        ``// Initialize priority queue with``        ``// 1 to N``        ``for` `(``int` `i = 1; i <= N; i++)``        ``{``            ``pq.Add(i);``        ``}``         ` `        ``pq.Sort();` `        ``// Perform the operations while``        ``// there are at least 2 elements``        ``while` `(pq.Count > 1)``        ``{``            ``// Get the maximum and``            ``// the second maximum``            ``int` `x = pq[pq.Count - 1];``            ``pq.RemoveAt(pq.Count - 1);``            ``int` `y = pq[pq.Count - 1];``            ``pq.RemoveAt(pq.Count - 1);` `            ``// Push (x^2 + y^2)``            ``pq.Add(x * x + y * y);``            ``pq.Sort();``        ``}` `        ``// Return the only element left``        ``return` `pq[0];``    ``}` `    ``static` `void` `Main(``string``[] args)``    ``{``        ``int` `N = 3;``        ``Console.WriteLine(reduceOne(N));``    ``}``}`

Output

`170`

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