# Find pairs with given sum such that elements of pair are in different rows

Given a matrix of distinct values and a sum. The task is to find all the pairs in given whose summation is equal to given sum. Each element of pair must be from different rows i.e; pair must not lie in same row.

**Examples:**

Input : mat[4][4] = {{1, 3, 2, 4}, {5, 8, 7, 6}, {9, 10, 13, 11}, {12, 0, 14, 15}} sum = 11 Output: (1, 10), (3, 8), (2, 9), (4, 7), (11, 0)

**Method 1 (Simple)**

A simple solution for this problem is to one by one take each element of all rows and find pair starting from immediate next row with in matrix. Time complexity for this approach will be O(n^{4}).

**Method 2 (Use Sorting)**

- Sort all the rows in ascending order. Time complexity for this preprocessing will be O(n
^{2}logn). - Now we will select each row one by one and find pair element in remaining rows after current row.
- Take two iterators
**left**and**right**.**left**iterator points left corner of current i’th row and**right**iterator points right corner of next j’th row in which we are going to find pair element. - If
**mat[i][left] + mat[j][right] < sum**then**left++**i.e; move in i’th row towards right corner, otherwise**right++**i.e; move in j’th row towards left corner.

## C++

`// C++ program to find a pair with given sum such that ` `// every element of pair is in different rows. ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `MAX = 100; ` ` ` `// Function to find pair for given sum in matrix ` `// mat[][] --> given matrix ` `// n --> order of matrix ` `// sum --> given sum for which we need to find pair ` `void` `pairSum(` `int` `mat[][MAX], ` `int` `n, ` `int` `sum) ` `{ ` ` ` `// First sort all the rows in ascending order ` ` ` `for` `(` `int` `i=0; i<n; i++) ` ` ` `sort(mat[i], mat[i]+n); ` ` ` ` ` `// Select i'th row and find pair for element in i'th ` ` ` `// row in j'th row whose summation is equal to given sum ` ` ` `for` `(` `int` `i=0; i<n-1; i++) ` ` ` `{ ` ` ` `for` `(` `int` `j=i+1; j<n; j++) ` ` ` `{ ` ` ` `int` `left = 0, right = n-1; ` ` ` `while` `(left<n && right>=0) ` ` ` `{ ` ` ` `if` `((mat[i][left] + mat[j][right]) == sum) ` ` ` `{ ` ` ` `cout << ` `"("` `<< mat[i][left] ` ` ` `<< ` `", "` `<< mat[j][right] << ` `"), "` `; ` ` ` `left++; ` ` ` `right--; ` ` ` `} ` ` ` `else` ` ` `{ ` ` ` `if` `((mat[i][left] + mat[j][right]) < sum) ` ` ` `left++; ` ` ` `else` ` ` `right--; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `} ` `} ` ` ` `// Driver program to run the case ` `int` `main() ` `{ ` ` ` `int` `n = 4, sum = 11; ` ` ` `int` `mat[][MAX] = {{1, 3, 2, 4}, ` ` ` `{5, 8, 7, 6}, ` ` ` `{9, 10, 13, 11}, ` ` ` `{12, 0, 14, 15}}; ` ` ` `pairSum(mat, n, sum); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to find a pair with ` `// given sum such that every element ` `// of pair is in different rows. ` `import` `java.util.Arrays; ` `class` `GFG { ` `static` `final` `int` `MAX = ` `100` `; ` ` ` `// Function to find pair for given sum in ` `// matrix mat[][] --> given matrix ` `// n --> order of matrix ` `// sum --> given sum for which we need to find pair ` `static` `void` `pairSum(` `int` `mat[][], ` `int` `n, ` `int` `sum) { ` ` ` ` ` `// First sort all the rows in ascending order ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `Arrays.sort(mat[i]); ` ` ` ` ` `// Select i'th row and find pair for element in i'th ` ` ` `// row in j'th row whose summation is equal to given sum ` ` ` `for` `(` `int` `i = ` `0` `; i < n - ` `1` `; i++) { ` ` ` `for` `(` `int` `j = i + ` `1` `; j < n; j++) { ` ` ` `int` `left = ` `0` `, right = n - ` `1` `; ` ` ` `while` `(left < n && right >= ` `0` `) { ` ` ` `if` `((mat[i][left] + mat[j][right]) == sum) { ` ` ` `System.out.print(` `"("` `+ mat[i][left] + ` `", "` `+ ` ` ` `mat[j][right] + ` `"), "` `); ` ` ` `left++; ` ` ` `right--; ` ` ` `} ` ` ` `else` `{ ` ` ` `if` `((mat[i][left] + mat[j][right]) < sum) ` ` ` `left++; ` ` ` `else` ` ` `right--; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `} ` `} ` ` ` `// Driver code ` `public` `static` `void` `main(String[] args) { ` ` ` `int` `n = ` `4` `, sum = ` `11` `; ` ` ` `int` `mat[] ` ` ` `[] = {{` `1` `, ` `3` `, ` `2` `, ` `4` `}, ` ` ` `{` `5` `, ` `8` `, ` `7` `, ` `6` `}, ` ` ` `{` `9` `, ` `10` `, ` `13` `, ` `11` `}, ` ` ` `{` `12` `, ` `0` `, ` `14` `, ` `15` `}}; ` ` ` `pairSum(mat, n, sum); ` `} ` `} ` `// This code is contributed by Anant Agarwal. ` |

*chevron_right*

*filter_none*

## Python 3

# Python 3 program to find a pair with

# given sum such that every element of

# pair is in different rows.

MAX = 100

# Function to find pair for given

# sum in matrix mat[][] –> given matrix

# n –> order of matrix

# sum –> given sum for which we

# need to find pair

def pairSum(mat, n, sum):

# First sort all the rows

# in ascending order

for i in range(n):

mat[i].sort()

# Select i’th row and find pair for

# element in i’th row in j’th row

# whose summation is equal to given sum

for i in range(n – 1):

for j in range(i + 1, n):

left = 0

right = n – 1

while (left < n and right >= 0):

if ((mat[i][left] + mat[j][right]) == sum):

print( “(“, mat[i][left],

“, “, mat[j][right], “), “,

end = ” “)

left += 1

right -= 1

else:

if ((mat[i][left] +

mat[j][right]) < sum):
left += 1
else:
right -= 1
# Driver Code
if __name__ == "__main__":
n = 4
sum = 11
mat = [[1, 3, 2, 4],
[5, 8, 7, 6],
[9, 10, 13, 11],
[12, 0, 14, 15]]
pairSum(mat, n, sum)
# This code is contributed
# by ChitraNayal
[tabbyending]
**Output:**

(1, 10), (3, 8), (2, 9), (4, 7), (11, 0)

**Time complexity :** O(n^{2}logn + n^3)

**Auxiliary space :** O(1)

**Method 3 (Hashing)**

- Create an empty hash table and store all elements of matrix in hash as key and their locations as values.
- Traverse the matrix again to check for every element whether its pair exists in hash table or not. If exists, then compare row numbers. If row numbers are not same, then print the pair.

## CPP

`// C++ program to find pairs with given sum such ` `// the two elements of pairs are from different rows ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `MAX = 100; ` ` ` `// Function to find pair for given sum in matrix ` `// mat[][] --> given matrix ` `// n --> order of matrix ` `// sum --> given sum for which we need to find pair ` `void` `pairSum(` `int` `mat[][MAX], ` `int` `n, ` `int` `sum) ` `{ ` ` ` `// Create a hash and store all elements of matrix ` ` ` `// as keys, and row and column numbers as values ` ` ` `unordered_map<` `int` `, pair<` `int` `, ` `int` `> > hm; ` ` ` `for` `(` `int` `i=0; i<n; i++) ` ` ` `for` `(` `int` `j=0; j<n; j++) ` ` ` `hm[mat[i][j]] = make_pair(i, j); ` ` ` ` ` `// Traverse the matrix again to check for every ` ` ` `// element whether its pair exists or not. ` ` ` `for` `(` `int` `i=0; i<n; i++) ` ` ` `{ ` ` ` `for` `(` `int` `j=0; j<n; j++) ` ` ` `{ ` ` ` `// Look for remaining sum in hash ` ` ` `int` `remSum = sum - mat[i][j]; ` ` ` `auto` `it = hm.find(remSum); ` `// it is an iterator ` ` ` `// of unordered_map type ` ` ` ` ` `// If an element with value equal to remaining sum exists ` ` ` `if` `(it != hm.end()) ` ` ` `{ ` ` ` `// Find row and column numbers of element with ` ` ` `// value equal to remaining sum. ` ` ` `pair<` `int` `, ` `int` `> p = it->second; ` ` ` `int` `row = p.first, col = p.second; ` ` ` ` ` `// If row number of pair is not same as current ` ` ` `// row, then print it as part of result. ` ` ` `// Second condition is there to make sure that a ` ` ` `// pair is printed only once. ` ` ` `if` `(row != i && row > i) ` ` ` `cout << ` `"("` `<< mat[i][j] << ` `", "` ` ` `<< mat[row][col] << ` `"), "` `; ` ` ` `} ` ` ` `} ` ` ` `} ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `n = 4, sum = 11; ` ` ` `int` `mat[][MAX]= {{1, 3, 2, 4}, ` ` ` `{5, 8, 7, 6}, ` ` ` `{9, 10, 13, 11}, ` ` ` `{12, 0, 14, 15}}; ` ` ` `pairSum(mat, n, sum); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output :

(1, 10), (3, 8), (2, 9), (4, 7), (11, 0),

One important thing is, when we traverse a matrix, a pair may be printed twice. To make sure that a pair is printed only once, we check if row number of other element picked from hash table is more than row number of current element.

Time Complexity : O(n^{2}) under the assumption that hash table insert and search operations take O(1) time.

This article is contributed by **Shashank Mishra ( Gullu )**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Recommended Posts:

- Find pair of rows in a binary matrix that has maximum bit difference
- Find distinct elements common to all rows of a matrix
- Find a pair of elements swapping which makes sum of two arrays same
- Common elements in all rows of a given matrix
- Interchange elements of first and last rows in matrix
- Maximum difference of sum of elements in two rows in a matrix
- Pair with given product | Set 1 (Find if any pair exists)
- Find all permuted rows of a given row in a matrix
- Find duplicate rows in a binary matrix
- Given an array of pairs, find all symmetric pairs in it
- Find a common element in all rows of a given row-wise sorted matrix
- Python Counter| Find duplicate rows in a binary matrix
- Find a pair with given sum in BST
- Count of index pairs with equal elements in an array
- Find a specific pair in Matrix