Find two non-overlapping pairs having equal sum in an Array

Given an unsorted array of integers. The task is to find any two non-overlapping pairs whose sum is equal.
Two pairs are said to be non-overlapping if all the elements of the pairs are at different indices. That is, pair (A_i, A_j) and pair (A_m, A_n) are said to be non-overlapping if i ? j ? m ? n.

Examples: 

Input: arr[] = {8, 4, 7, 8, 4}
Output: Pair First(4, 8)
        Pair Second (8, 4)

Input: arr[] = {8, 4, 7, 4}
Output: No such non-overlapping pairs present.

Note: (8, 4) and (8, 4) forms overlapping pair
as index of 8 is same in both pairs.

The idea is to use a map of key-value pair to store all occurrences of a sum. The key in the map will store the sum and the corresponding value will be a list of pair of indices (i, j) with that sum.  

• The idea is to traverse the array and generate all possible pairs.
• If a new sum is found, insert it directly to the map otherwise check if any of the previously encountered pairs with that sum does not overlap with current pair.
• If not, print both of the pairs.

Below is implementation of the above approach: 

C++

// C++ programs to find two non-overlapping
// pairs having equal sum in an Array

#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;

typedef pair<int, int> Pair;

// Function to find two non-overlapping
// with same sum in an array
void findPairs(int arr[], int n)
{
    // first create an empty map
    // key -> which is sum of a pair of
    // elements in the array
    // value -> vector storing index of
    // every pair having that sum
    unordered_map<int, vector<Pair> > map;

    // consider every pair (arr[i], arr[j])
    // and where (j > i)
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {

            // calculate sum of current pair
            int sum = arr[i] + arr[j];

            // if sum is already present in the map
            if (map.find(sum) != map.end()) {

                // check every pair having equal sum
                for (auto pair : map.find(sum)->second) {
                    int m = pair.first, n = pair.second;

                    // if pairs don't overlap,
                    // print them and return
                    if ((m != i && m != j) && (n != i && n != j)) {
                        cout << "Pair First(" << arr[i] << ", "
                             << arr[j] << ")\nPair Second ("
                             << arr[m] << ", " << arr[n] << ")";
                        return;
                    }
                }
            }

            // Insert current pair into the map
            map[sum].push_back({ i, j });
        }
    }

    // If no such pair found
    cout << "No such non-overlapping pairs present";
}

// Driver Code
int main()
{
    int arr[] = { 8, 4, 7, 8, 4 };
    int size = sizeof(arr) / sizeof(arr[0]);

    findPairs(arr, size);

    return 0;
}

Java

// Java program to find two non-overlapping
// pairs having equal sum in an Array

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// Declare a pair
class Pair {
    public int x, y;

    Pair(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

class GFG {
    // Function to find two non-overlapping
    // pairs with same sum in an array
    public static void findPairs(int[] A)
    {
        // first create an empty map
        // key -> which is sum of a pair
        // of elements in the array
        // value -> list storing index of
        // every pair having that sum
        Map<Integer, List<Pair> > map = new HashMap<>();

        // consider every pair (A[i], A[j]) where (j > i)
        for (int i = 0; i < A.length - 1; i++) {
            for (int j = i + 1; j < A.length; j++) {

                // calculate sum of current pair
                int sum = A[i] + A[j];

                // if sum is already present in the map
                if (map.containsKey(sum)) {

                    // check every pair having desired sum
                    for (Pair pair : map.get(sum)) {
                        int x = pair.x;
                        int y = pair.y;

                        // if pairs don't overlap, print
                        // them and return
                        if ((x != i && x != j) && (y != i && y != j)) {
                            System.out.println("Pair First(" + A[i] + ", "
                                               + A[j] + ")");

                            System.out.println("Pair Second (" + A[x] + ", "
                                               + A[y] + ")");

                            return;
                        }
                    }
                }

                // Insert current pair into the map
                map.putIfAbsent(sum, new ArrayList<>());
                map.get(sum).add(new Pair(i, j));
            }
        }

        System.out.print("No such non-overlapping pairs present");
    }

    // Driver Code
    public static void main(String[] args)
    {
        int[] A = { 8, 4, 7, 8, 4 };

        findPairs(A);
    }
}

Python3

# Python3 programs to find two non-overlapping
# pairs having equal Sum in an Array

# Function to find two non-overlapping
# with same Sum in an array
def findPairs(arr, size):

    # first create an empty Map
    # key -> which is Sum of a pair of
    # elements in the array
    # value -> vector storing index of
    # every pair having that Sum
    Map = {}

    # consider every pair (arr[i], arr[j])
    # and where (j > i)
    for i in range(0, size - 1):
        for j in range(i + 1, size):

            # calculate Sum of current pair
            Sum = arr[i] + arr[j]

            # if Sum is already present in the Map
            if Sum in Map:

                # check every pair having equal Sum
                for pair in Map[Sum]:
                    m, n = pair

                    # if pairs don't overlap,
                    # print them and return
                    if ((m != i and m != j) and
                        (n != i and n != j)):

                        print("Pair First ({}, {})".
                               format(arr[i], arr[j]))
                        print("Pair Second ({}, {})".
                               format(arr[m], arr[n]))
                        return

            # Insert current pair into the Map
            if Sum not in Map:
                Map[Sum] = []
            Map[Sum].append((i, j))

    # If no such pair found
    print("No such non-overlapping pairs present")

# Driver Code
if __name__ == "__main__":

    arr = [8, 4, 7, 8, 4]
    size = len(arr)

    findPairs(arr, size)

# This code is contributed by Rituraj Jain

C#

// C# program to find two non-overlapping
// pairs having equal sum in an Array
using System;
using System.Collections.Generic;

// Declare a pair
class Pair
{
    public int x, y;

    public Pair(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

class GFG{

// Function to find two non-overlapping
// pairs with same sum in an array
public static void findPairs(int[] A)
{

    // First create an empty map
    // key -> which is sum of a pair
    // of elements in the array
    // value -> list storing index of
    // every pair having that sum
    Dictionary<int,
               List<Pair>> map = new Dictionary<int,
                                                List<Pair>>();

    // Consider every pair (A[i], A[j])
    // where (j > i)
    for(int i = 0; i < A.Length - 1; i++)
    {
        for(int j = i + 1; j < A.Length; j++)
        {

            // Calculate sum of current pair
            int sum = A[i] + A[j];

            // If sum is already present in the map
            if (map.ContainsKey(sum))
            {

                // Check every pair having desired sum
                foreach(Pair pair in map[sum])
                {
                    int x = pair.x;
                    int y = pair.y;

                    // If pairs don't overlap, print
                    // them and return
                    if ((x != i && x != j) &&
                        (y != i && y != j))
                    {
                        Console.WriteLine("Pair First(" + A[i] +
                                          ", " + A[j] + ")");

                        Console.WriteLine("Pair Second (" + A[x] +
                                          ", " + A[y] + ")");

                        return;
                    }
                }
            }

            // Insert current pair into the map
            map[sum] = new List<Pair>();
            map[sum].Add(new Pair(i, j));
        }
    }

    Console.Write("No such non-overlapping pairs present");
}

// Driver Code
public static void Main(String[] args)
{
    int[] A = { 8, 4, 7, 8, 4 };

    findPairs(A);
}
}

// This code is contributed by Princi Singh

Javascript

// Declare a pair
class Pair {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}

// Function to find two non-overlapping
// pairs with same sum in an array
function findPairs(A)
{

  // first create an empty map
  // key -> which is sum of a pair
  // of elements in the array
  // value -> list storing index of
  // every pair having that sum
  const map = new Map();

  // consider every pair (A[i], A[j]) where (j > i)
  for (let i = 0; i < A.length - 1; i++) {
    for (let j = i + 1; j < A.length; j++) {
      // calculate sum of current pair
      const sum = A[i] + A[j];

      // if sum is already present in the map
      if (map.has(sum)) {
        // check every pair having desired sum
        for (const pair of map.get(sum)) {
          const x = pair.x;
          const y = pair.y;

          // if pairs don't overlap, print
          // them and return
          if ((x !== i && x !== j) && (y !== i && y !== j)) {
            console.log(`Pair First(${A[i]}, ${A[j]})`);
            console.log(`Pair Second(${A[x]}, ${A[y]})`);
            return;
          }
        }
      }

      // Insert current pair into the map
      if (!map.has(sum)) {
        map.set(sum, []);
      }
      map.get(sum).push(new Pair(i, j));
    }
  }

  console.log("No such non-overlapping pairs present");
}

// Driver Code
const A = [8, 4, 7, 8, 4];
findPairs(A);

// This code is contributed by phasing17.

Output

Pair First(4, 8)
Pair Second (8, 4)

Time Complexity: O(n²)
Auxiliary Space: O(n²)