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 X² + Y²in 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 (X² + Y²). 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² + Y²) 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 <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;
}

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

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)