Open In App

# Maximum pair sum in the given index ranges of an Array

Given an array arr containing N positive integers and the number of queries Q, for each query task is to find the maximum pair sum in the given index range [L, R] where L and R are the respective low and high indices.
Examples:

Input: arr = {3, 4, 5, 6, 7, 8}, Q[][2] = [[0, 3], [3, 5]]
Output:
11
15
Explanation:
For the first query, subarray is [3, 4, 5, 6]
All the pairs are (3, 4), (3, 5), (3, 6), (4, 5), (4, 6), (5, 6)
Hence the maximum pair sum = (5 + 6) = 11
For the second query, subarray is [6, 7, 8]
All the pairs of the subarray are (6, 7), (6, 8), (7, 8)
Hence the maximum pair sum = (7 + 8) = 15

Naive Approach: For each query range, do the following

1. Find the maximum and the second maximum in the given query range.
2. Sum of maximum and second maximum will be the maximum pair sum of the given range.

Below is the implementation of the above approach:

## C++

 `// C++ program to find maximum``// pair sum in the given``// index range of an Array``#include ``using` `namespace` `std;` `// Node structure to store a query``struct` `node {``    ``int` `f;``    ``int` `s;``};` `// Function to find the required sum``void` `findSum(``int``* arr, ``int` `n,``             ``int` `Q, node* query)``{` `    ``// Run a loop to iterate``    ``// over query array``    ``for` `(``int` `i = 0; i < Q; i++) {` `        ``// declare first 'f'``        ``// and second 's' variables``        ``int` `f, s;` `        ``// Initialise them with 0``        ``f = s = 0;` `        ``// Iterate over the``        ``// given array from``        ``// range query[i].f to query[i].s``        ``for` `(``int` `j = query[i].f;``             ``j <= query[i].s;``             ``j++) {` `            ``// If the array element``            ``// value is greater than``            ``// current f, store``            ``// current f in s and``            ``// array element value in f``            ``if` `(arr[j] >= f) {``                ``s = f;` `                ``f = arr[j];``            ``}``            ``// else if element``            ``// is greater than s,``            ``// update s with``            ``// array element value``            ``else` `if` `(arr[j] > s)``                ``s = arr[j];``        ``}` `        ``// print the sum of f and s``        ``cout << (f + s) << endl;``    ``}``}` `// Driver code``int` `main()``{``    ``// Given array and number of queries``    ``int` `arr[] = { 3, 4, 5, 6, 7, 8 }, Q = 2;``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Declare and define queries``    ``node query[Q];``    ``query[0] = { 0, 3 };``    ``query[1] = { 3, 5 };` `    ``findSum(arr, n, Q, query);``}`

## Java

 `// Java program to find maximum``// pair sum in the given``// index range of an Array``class` `GFG{`` ` `// Node structure to store a query``static` `class` `node {``    ``int` `f;``    ``int` `s;``    ``public` `node(``int` `f, ``int` `s) {``        ``this``.f = f;``        ``this``.s = s;``    ``}``    ` `};`` ` `// Function to find the required sum``static` `void` `findSum(``int` `[]arr, ``int` `n,``             ``int` `Q, node []query)``{`` ` `    ``// Run a loop to iterate``    ``// over query array``    ``for` `(``int` `i = ``0``; i < Q; i++) {`` ` `        ``// declare first 'f'``        ``// and second 's' variables``        ``int` `f, s;`` ` `        ``// Initialise them with 0``        ``f = s = ``0``;`` ` `        ``// Iterate over the``        ``// given array from``        ``// range query[i].f to query[i].s``        ``for` `(``int` `j = query[i].f;``             ``j <= query[i].s;``             ``j++) {`` ` `            ``// If the array element``            ``// value is greater than``            ``// current f, store``            ``// current f in s and``            ``// array element value in f``            ``if` `(arr[j] >= f) {``                ``s = f;`` ` `                ``f = arr[j];``            ``}``            ``// else if element``            ``// is greater than s,``            ``// update s with``            ``// array element value``            ``else` `if` `(arr[j] > s)``                ``s = arr[j];``        ``}`` ` `        ``// print the sum of f and s``        ``System.out.print((f + s) +``"\n"``);``    ``}``}`` ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``// Given array and number of queries``    ``int` `arr[] = { ``3``, ``4``, ``5``, ``6``, ``7``, ``8` `}, Q = ``2``;``    ``int` `n = arr.length;`` ` `    ``// Declare and define queries``    ``node []query = ``new` `node[``2``];``    ``query[``0``] = ``new` `node( ``0``, ``3` `);``    ``query[``1``] =  ``new` `node(``3``, ``5` `);`` ` `    ``findSum(arr, n, Q, query);``}``}` `// This code is contributed by PrinciRaj1992`

## Python3

 `# Python program to find maximum``# pair sum in the given``# index range of an Array` `# Node structure to store a query``from` `pickle ``import` `NONE` `class` `node:``    ``def` `__init__(``self``, f, s):``        ``self``.f ``=` `f``        ``self``.s ``=` `s` `# Function to find the required sum``def` `findSum(arr, n, Q, query):` `    ``# Run a loop to iterate``    ``# over query array``    ``for` `i ``in` `range``(Q):` `        ``# declare first 'f'``        ``# and second 's' variables` `        ``# Initialise them with 0``        ``f,s ``=` `0``,``0` `        ``# Iterate over the``        ``# given array from``        ``# range query[i].f to query[i].s``        ``for` `j ``in` `range``(query[i].f,query[i].s``+``1``):` `            ``# If the array element``            ``# value is greater than``            ``# current f, store``            ``# current f in s and``            ``# array element value in f``            ``if` `(arr[j] >``=` `f):``                ``s ``=` `f``                ``f ``=` `arr[j]` `            ``# else if element``            ``# is greater than s,``            ``# update s with``            ``# array element value``            ``elif` `(arr[j] > s):``                ``s ``=` `arr[j]` `        ``# print the sum of f and s``        ``print``(f ``+` `s)` `# Driver code` `# Given array and number of queries``arr ``=` `[ ``3``, ``4``, ``5``, ``6``, ``7``, ``8` `]``Q ``=` `2``n ``=` `len``(arr)` `# Declare and define queries``query ``=` `[``None``]``*``Q``query[``0``] ``=` `node( ``0``, ``3` `)``query[``1``] ``=` `node( ``3``, ``5` `)` `findSum(arr, n, Q, query)` `# This code is contributed by shinjanpatra`

## C#

 `// C# program to find maximum``// pair sum in the given``// index range of an Array``using` `System;` `class` `GFG{``  ` `// Node structure to store a query``class` `node {``    ``public` `int` `f;``    ``public` `int` `s;``    ``public` `node(``int` `f, ``int` `s) {``        ``this``.f = f;``        ``this``.s = s;``    ``}``     ` `};``  ` `// Function to find the required sum``static` `void` `findSum(``int` `[]arr, ``int` `n,``             ``int` `Q, node []query)``{``  ` `    ``// Run a loop to iterate``    ``// over query array``    ``for` `(``int` `i = 0; i < Q; i++) {``  ` `        ``// declare first 'f'``        ``// and second 's' variables``        ``int` `f, s;``  ` `        ``// Initialise them with 0``        ``f = s = 0;``  ` `        ``// Iterate over the``        ``// given array from``        ``// range query[i].f to query[i].s``        ``for` `(``int` `j = query[i].f;``             ``j <= query[i].s;``             ``j++) {``  ` `            ``// If the array element``            ``// value is greater than``            ``// current f, store``            ``// current f in s and``            ``// array element value in f``            ``if` `(arr[j] >= f) {``                ``s = f;``  ` `                ``f = arr[j];``            ``}``            ``// else if element``            ``// is greater than s,``            ``// update s with``            ``// array element value``            ``else` `if` `(arr[j] > s)``                ``s = arr[j];``        ``}``  ` `        ``// print the sum of f and s``        ``Console.Write((f + s) +``"\n"``);``    ``}``}``  ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``// Given array and number of queries``    ``int` `[]arr = { 3, 4, 5, 6, 7, 8 };``    ``int` `Q = 2;``    ``int` `n = arr.Length;``  ` `    ``// Declare and define queries``    ``node []query = ``new` `node[2];``    ``query[0] = ``new` `node( 0, 3 );``    ``query[1] =  ``new` `node(3, 5 );``  ` `    ``findSum(arr, n, Q, query);``}``}`` ` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

```11
15```

Performance Analysis:

• Time Complexity: In the above approach, we are looper over the array of length N for each of Q query. Thus the time complexity would be O(N*Q).
• Auxiliary Space: In the above approach there is no extra space used, therefore the Auxiliary Space complexity will be O(1).

Efficient Approach: The idea is to use the segment tree where each node of the segment tree store two values:

• Maximum of the given below subtree
• Second maximum of the given below subtree
• Time Complexity: In the above approach, we are building a segment tree which is of time complexity O(N) Then for each of Q queries, we find the solution in O(logN) time. So overall time complexity is O(N+Q*logN)

• Auxiliary Space Complexity: In the above approach, we are using extra space for storing the segment tree which is taking (4 * N + 1) space. So Auxiliary space complexity is O(N)