# Find a common element in all rows of a given row-wise sorted matrix

Given a matrix where every row is sorted in increasing order. Write a function that finds and returns a common element in all rows. If there is no common element, then returns -1.

Example:

```Input: mat = { {1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},
};
Output: 5```

A O(m*n*n) simple solution is to take every element of first row and search it in all other rows, till we find a common element. Time complexity of this solution is O(m*n*n) where m is number of rows and n is number of columns in given matrix. This can be improved to O(m*n*Logn) if we use Binary Search instead of linear search.

We can solve this problem in O(mn) time using the approach similar to merge of Merge Sort. The idea is to start from the last column of every row. If elements at all last columns are same, then we found the common element. Otherwise we find the minimum of all last columns. Once we find a minimum element, we know that all other elements in last columns cannot be a common element, so we reduce last column index for all rows except for the row which has minimum value. We keep repeating these steps till either all elements at current last column don’t become same, or a last column index reaches 0.

Below is the implementation of above idea.

## C++

 `// A C++ program to find a common element in all rows of a ` `// row wise sorted array ` `#include ` `using` `namespace` `std; ` ` `  `// Specify number of rows and columns ` `#define M 4 ` `#define N 5 ` ` `  `// Returns common element in all rows of mat[M][N]. If there is no ` `// common element, then -1 is returned ` `int` `findCommon(``int` `mat[M][N]) ` `{ ` `    ``// An array to store indexes of current last column ` `    ``int` `column[M]; ` `    ``int` `min_row; ``// To store index of row whose current ` `    ``// last element is minimum ` ` `  `    ``// Initialize current last element of all rows ` `    ``int` `i; ` `    ``for` `(i = 0; i < M; i++) ` `        ``column[i] = N - 1; ` ` `  `    ``min_row = 0; ``// Initialize min_row as first row ` ` `  `    ``// Keep finding min_row in current last column, till either ` `    ``// all elements of last column become same or we hit first column. ` `    ``while` `(column[min_row] >= 0) { ` `        ``// Find minimum in current last column ` `        ``for` `(i = 0; i < M; i++) { ` `            ``if` `(mat[i][column[i]] < mat[min_row][column[min_row]]) ` `                ``min_row = i; ` `        ``} ` ` `  `        ``// eq_count is count of elements equal to minimum in current last ` `        ``// column. ` `        ``int` `eq_count = 0; ` ` `  `        ``// Traverse current last column elements again to update it ` `        ``for` `(i = 0; i < M; i++) { ` `            ``// Decrease last column index of a row whose value is more ` `            ``// than minimum. ` `            ``if` `(mat[i][column[i]] > mat[min_row][column[min_row]]) { ` `                ``if` `(column[i] == 0) ` `                    ``return` `-1; ` ` `  `                ``column[i] -= 1; ``// Reduce last column index by 1 ` `            ``} ` `            ``else` `                ``eq_count++; ` `        ``} ` ` `  `        ``// If equal count becomes M, return the value ` `        ``if` `(eq_count == M) ` `            ``return` `mat[min_row][column[min_row]]; ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `mat[M][N] = { ` `        ``{ 1, 2, 3, 4, 5 }, ` `        ``{ 2, 4, 5, 8, 10 }, ` `        ``{ 3, 5, 7, 9, 11 }, ` `        ``{ 1, 3, 5, 7, 9 }, ` `    ``}; ` `    ``int` `result = findCommon(mat); ` `    ``if` `(result == -1) ` `        ``cout << ``"No common element"``; ` `    ``else` `        ``cout << ``"Common element is "` `<< result; ` `    ``return` `0; ` `} ` ` `  `// This code is contributed ` `// by Akanksha Rai `

## C

 `// A C program to find a common element in all rows of a ` `// row wise sorted array ` `#include ` ` `  `// Specify number of rows and columns ` `#define M 4 ` `#define N 5 ` ` `  `// Returns common element in all rows of mat[M][N]. If there is no ` `// common element, then -1 is returned ` `int` `findCommon(``int` `mat[M][N]) ` `{ ` `    ``// An array to store indexes of current last column ` `    ``int` `column[M]; ` `    ``int` `min_row; ``// To store index of row whose current ` `    ``// last element is minimum ` ` `  `    ``// Initialize current last element of all rows ` `    ``int` `i; ` `    ``for` `(i = 0; i < M; i++) ` `        ``column[i] = N - 1; ` ` `  `    ``min_row = 0; ``// Initialize min_row as first row ` ` `  `    ``// Keep finding min_row in current last column, till either ` `    ``// all elements of last column become same or we hit first column. ` `    ``while` `(column[min_row] >= 0) { ` `        ``// Find minimum in current last column ` `        ``for` `(i = 0; i < M; i++) { ` `            ``if` `(mat[i][column[i]] < mat[min_row][column[min_row]]) ` `                ``min_row = i; ` `        ``} ` ` `  `        ``// eq_count is count of elements equal to minimum in current last ` `        ``// column. ` `        ``int` `eq_count = 0; ` ` `  `        ``// Traverse current last column elements again to update it ` `        ``for` `(i = 0; i < M; i++) { ` `            ``// Decrease last column index of a row whose value is more ` `            ``// than minimum. ` `            ``if` `(mat[i][column[i]] > mat[min_row][column[min_row]]) { ` `                ``if` `(column[i] == 0) ` `                    ``return` `-1; ` ` `  `                ``column[i] -= 1; ``// Reduce last column index by 1 ` `            ``} ` `            ``else` `                ``eq_count++; ` `        ``} ` ` `  `        ``// If equal count becomes M, return the value ` `        ``if` `(eq_count == M) ` `            ``return` `mat[min_row][column[min_row]]; ` `    ``} ` `    ``return` `-1; ` `} ` ` `  `// driver program to test above function ` `int` `main() ` `{ ` `    ``int` `mat[M][N] = { ` `        ``{ 1, 2, 3, 4, 5 }, ` `        ``{ 2, 4, 5, 8, 10 }, ` `        ``{ 3, 5, 7, 9, 11 }, ` `        ``{ 1, 3, 5, 7, 9 }, ` `    ``}; ` `    ``int` `result = findCommon(mat); ` `    ``if` `(result == -1) ` `        ``printf``(``"No common element"``); ` `    ``else` `        ``printf``(``"Common element is %d"``, result); ` `    ``return` `0; ` `} `

## Java

 `// A Java program to find a common ` `// element in all rows of a ` `// row wise sorted array ` ` `  `class` `GFG { ` `    ``// Specify number of rows and columns ` `    ``static` `final` `int` `M = ``4``; ` `    ``static` `final` `int` `N = ``5``; ` ` `  `    ``// Returns common element in all rows ` `    ``// of mat[M][N]. If there is no ` `    ``// common element, then -1 is ` `    ``// returned ` `    ``static` `int` `findCommon(``int` `mat[][]) ` `    ``{ ` `        ``// An array to store indexes ` `        ``// of current last column ` `        ``int` `column[] = ``new` `int``[M]; ` ` `  `        ``// To store index of row whose current ` `        ``// last element is minimum ` `        ``int` `min_row; ` ` `  `        ``// Initialize current last element of all rows ` `        ``int` `i; ` `        ``for` `(i = ``0``; i < M; i++) ` `            ``column[i] = N - ``1``; ` ` `  `        ``// Initialize min_row as first row ` `        ``min_row = ``0``; ` ` `  `        ``// Keep finding min_row in current last column, till either ` `        ``// all elements of last column become same or we hit first column. ` `        ``while` `(column[min_row] >= ``0``) { ` `            ``// Find minimum in current last column ` `            ``for` `(i = ``0``; i < M; i++) { ` `                ``if` `(mat[i][column[i]] < mat[min_row][column[min_row]]) ` `                    ``min_row = i; ` `            ``} ` ` `  `            ``// eq_count is count of elements equal to minimum in current last ` `            ``// column. ` `            ``int` `eq_count = ``0``; ` ` `  `            ``// Traverse current last column elements again to update it ` `            ``for` `(i = ``0``; i < M; i++) { ` `                ``// Decrease last column index of a row whose value is more ` `                ``// than minimum. ` `                ``if` `(mat[i][column[i]] > mat[min_row][column[min_row]]) { ` `                    ``if` `(column[i] == ``0``) ` `                        ``return` `-``1``; ` ` `  `                    ``// Reduce last column index by 1 ` `                    ``column[i] -= ``1``; ` `                ``} ` `                ``else` `                    ``eq_count++; ` `            ``} ` ` `  `            ``// If equal count becomes M, ` `            ``// return the value ` `            ``if` `(eq_count == M) ` `                ``return` `mat[min_row][column[min_row]]; ` `        ``} ` `        ``return` `-``1``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `mat[][] = { { ``1``, ``2``, ``3``, ``4``, ``5` `}, ` `                        ``{ ``2``, ``4``, ``5``, ``8``, ``10` `}, ` `                        ``{ ``3``, ``5``, ``7``, ``9``, ``11` `}, ` `                        ``{ ``1``, ``3``, ``5``, ``7``, ``9` `} }; ` `        ``int` `result = findCommon(mat); ` `        ``if` `(result == -``1``) ` `            ``System.out.print(``"No common element"``); ` `        ``else` `            ``System.out.print(``"Common element is "` `+ result); ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python 3

 `# Python 3 program to find a common element  ` `# in all rows of a row wise sorted array ` ` `  `# Specify number of rows  ` `# and columns ` `M ``=` `4` `N ``=` `5` ` `  `# Returns common element in all rows  ` `# of mat[M][N]. If there is no common  ` `# element, then -1 is returned ` `def` `findCommon(mat): ` ` `  `    ``# An array to store indexes of  ` `    ``# current last column ` `    ``column ``=` `[N ``-` `1``] ``*` `M ` ` `  `    ``min_row ``=` `0` `# Initialize min_row as first row ` ` `  `    ``# Keep finding min_row in current last  ` `    ``# column, till either all elements of  ` `    ``# last column become same or we hit first column. ` `    ``while` `(column[min_row] >``=` `0``): ` `     `  `        ``# Find minimum in current last column ` `        ``for` `i ``in` `range``(M): ` `            ``if` `(mat[i][column[i]] <  ` `                ``mat[min_row][column[min_row]]): ` `                ``min_row ``=` `i ` `     `  `        ``# eq_count is count of elements equal  ` `        ``# to minimum in current last column. ` `        ``eq_count ``=` `0` ` `  `        ``# Traverse current last column elements ` `        ``# again to update it ` `        ``for` `i ``in` `range``(M): ` `             `  `            ``# Decrease last column index of a row  ` `            ``# whose value is more than minimum. ` `            ``if` `(mat[i][column[i]] >  ` `                ``mat[min_row][column[min_row]]): ` `                ``if` `(column[i] ``=``=` `0``): ` `                    ``return` `-``1` ` `  `                ``column[i] ``-``=` `1` `# Reduce last column ` `                               ``# index by 1 ` `         `  `            ``else``: ` `                ``eq_count ``+``=` `1` ` `  `        ``# If equal count becomes M, return the value ` `        ``if` `(eq_count ``=``=` `M): ` `            ``return` `mat[min_row][column[min_row]] ` `    ``return` `-``1` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `     `  `    ``mat ``=` `[[``1``, ``2``, ``3``, ``4``, ``5``], ` `           ``[``2``, ``4``, ``5``, ``8``, ``10``], ` `           ``[``3``, ``5``, ``7``, ``9``, ``11``], ` `           ``[``1``, ``3``, ``5``, ``7``, ``9``]] ` ` `  `    ``result ``=` `findCommon(mat) ` `    ``if` `(result ``=``=` `-``1``): ` `        ``print``(``"No common element"``) ` `    ``else``: ` `        ``print``(``"Common element is"``, result) ` ` `  `# This code is contributed by ita_c `

## C#

 `// A C# program to find a common ` `// element in all rows of a ` `// row wise sorted array ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Specify number of rows and columns ` `    ``static` `int` `M = 4; ` `    ``static` `int` `N = 5; ` ` `  `    ``// Returns common element in all rows ` `    ``// of mat[M][N]. If there is no ` `    ``// common element, then -1 is ` `    ``// returned ` `    ``static` `int` `findCommon(``int``[, ] mat) ` `    ``{ ` ` `  `        ``// An array to store indexes ` `        ``// of current last column ` `        ``int``[] column = ``new` `int``[M]; ` ` `  `        ``// To store index of row whose ` `        ``// current last element is minimum ` `        ``int` `min_row; ` ` `  `        ``// Initialize current last element ` `        ``// of all rows ` `        ``int` `i; ` `        ``for` `(i = 0; i < M; i++) ` `            ``column[i] = N - 1; ` ` `  `        ``// Initialize min_row as first row ` `        ``min_row = 0; ` ` `  `        ``// Keep finding min_row in current ` `        ``// last column, till either all ` `        ``// elements of last column become ` `        ``// same or we hit first column. ` `        ``while` `(column[min_row] >= 0) { ` ` `  `            ``// Find minimum in current ` `            ``// last column ` `            ``for` `(i = 0; i < M; i++) { ` `                ``if` `(mat[i, column[i]] < mat[min_row, column[min_row]]) ` `                    ``min_row = i; ` `            ``} ` ` `  `            ``// eq_count is count of elements ` `            ``// equal to minimum in current ` `            ``// last column. ` `            ``int` `eq_count = 0; ` ` `  `            ``// Traverse current last column ` `            ``// elements again to update it ` `            ``for` `(i = 0; i < M; i++) { ` ` `  `                ``// Decrease last column index ` `                ``// of a row whose value is more ` `                ``// than minimum. ` `                ``if` `(mat[i, column[i]] > mat[min_row, column[min_row]]) { ` `                    ``if` `(column[i] == 0) ` `                        ``return` `-1; ` ` `  `                    ``// Reduce last column index ` `                    ``// by 1 ` `                    ``column[i] -= 1; ` `                ``} ` `                ``else` `                    ``eq_count++; ` `            ``} ` ` `  `            ``// If equal count becomes M, ` `            ``// return the value ` `            ``if` `(eq_count == M) ` `                ``return` `mat[min_row, ` `                           ``column[min_row]]; ` `        ``} ` ` `  `        ``return` `-1; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[, ] mat = { { 1, 2, 3, 4, 5 }, ` `                        ``{ 2, 4, 5, 8, 10 }, ` `                        ``{ 3, 5, 7, 9, 11 }, ` `                        ``{ 1, 3, 5, 7, 9 } }; ` ` `  `        ``int` `result = findCommon(mat); ` ` `  `        ``if` `(result == -1) ` `            ``Console.Write(``"No common element"``); ` `        ``else` `            ``Console.Write(``"Common element is "` `                          ``+ result); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007. `

Output:

```Common element is 5
```

Explanation for working of above code
Let us understand working of above code for following example.

Initially entries in last column array are N-1, i.e., {4, 4, 4, 4}
{1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},

The value of min_row is 0, so values of last column index for rows with value greater than 5 is reduced by one. So column[] becomes {4, 3, 3, 3}.
{1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},

The value of min_row remains 0 and and value of last column index for rows with value greater than 5 is reduced by one. So column[] becomes {4, 2, 2, 2}.
{1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},

The value of min_row remains 0 and value of last column index for rows with value greater than 5 is reduced by one. So colomun[] becomes {4, 2, 1, 2}.
{1, 2, 3, 4, 5},
{2, 4, 5, 8, 10},
{3, 5, 7, 9, 11},
{1, 3, 5, 7, 9},

Now all values in current last columns of all rows is same, so 5 is returned.

A Hashing Based Solution
We can also use hashing. This solution works even if the rows are not sorted. It can be used to print all common elements.

```Step1:  Create a Hash Table with all key as distinct elements
of row1. Value for all these will be 0.

Step2:
For i = 1 to M-1
For j = 0 to N-1
If (mat[i][j] is already present in Hash Table)
If (And this is not a repetition in current row.
This can be checked by comparing HashTable value with
row number)
Update the value of this key in HashTable with current
row number

Step3: Iterate over HashTable and print all those keys for
which value = M ```

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Specify number of rows and columns ` `#define M 4 ` `#define N 5 ` ` `  `// Returns common element in all rows of mat[M][N]. If there is no ` `// common element, then -1 is returned ` `int` `findCommon(``int` `mat[M][N]) ` `{ ` `    ``// A hash map to store count of elements ` `    ``unordered_map<``int``, ``int``> cnt; ` ` `  `    ``int` `i, j; ` ` `  `    ``for` `(i = 0; i < M; i++) { ` ` `  `        ``// Increment the count of first ` `        ``// element of the row ` `        ``cnt[mat[i]]++; ` ` `  `        ``// Starting from the second element ` `        ``// of the current row ` `        ``for` `(j = 1; j < N; j++) { ` ` `  `            ``// If current element is different from ` `            ``// the previous element i.e. it is appearing ` `            ``// for the first time in the current row ` `            ``if` `(mat[i][j] != mat[i][j - 1]) ` `                ``cnt[mat[i][j]]++; ` `        ``} ` `    ``} ` ` `  `    ``// Find element having count equal to number of rows ` `    ``for` `(``auto` `ele : cnt) { ` `        ``if` `(ele.second == M) ` `            ``return` `ele.first; ` `    ``} ` ` `  `    ``// No such element found ` `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `mat[M][N] = { ` `        ``{ 1, 2, 3, 4, 5 }, ` `        ``{ 2, 4, 5, 8, 10 }, ` `        ``{ 3, 5, 7, 9, 11 }, ` `        ``{ 1, 3, 5, 7, 9 }, ` `    ``}; ` `    ``int` `result = findCommon(mat); ` `    ``if` `(result == -1) ` `        ``cout << ``"No common element"``; ` `    ``else` `        ``cout << ``"Common element is "` `<< result; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Specify number of rows and columns ` `static` `int` `M = ``4``; ` `static` `int` `N = ``5``; ` ` `  `// Returns common element in all rows of mat[M][N]. ` `// If there is no common element, then -1 is returned ` `static` `int` `findCommon(``int` `mat[][]) ` `{ ` `    ``// A hash map to store count of elements ` `    ``HashMap cnt = ``new` `HashMap(); ` ` `  `    ``int` `i, j; ` ` `  `    ``for` `(i = ``0``; i < M; i++)  ` `    ``{ ` ` `  `        ``// Increment the count of first ` `        ``// element of the row ` `        ``if``(cnt.containsKey(mat[i][``0``])) ` `        ``{ ` `            ``cnt.put(mat[i][``0``],  ` `            ``cnt.get(mat[i][``0``]) + ``1``); ` `        ``} ` `        ``else` `        ``{ ` `            ``cnt.put(mat[i][``0``], ``1``); ` `        ``} ` ` `  `        ``// Starting from the second element ` `        ``// of the current row ` `        ``for` `(j = ``1``; j < N; j++)  ` `        ``{ ` ` `  `            ``// If current element is different from ` `            ``// the previous element i.e. it is appearing ` `            ``// for the first time in the current row ` `            ``if` `(mat[i][j] != mat[i][j - ``1``]) ` `                ``if``(cnt.containsKey(mat[i][j])) ` `                ``{ ` `                    ``cnt.put(mat[i][j],  ` `                    ``cnt.get(mat[i][j]) + ``1``); ` `                ``} ` `                ``else` `                ``{ ` `                    ``cnt.put(mat[i][j], ``1``); ` `                ``} ` `        ``} ` `    ``} ` ` `  `    ``// Find element having count  ` `    ``// equal to number of rows ` `    ``for` `(Map.Entry ele : cnt.entrySet()) ` `    ``{ ` `        ``if` `(ele.getValue() == M) ` `            ``return` `ele.getKey(); ` `    ``} ` ` `  `    ``// No such element found ` `    ``return` `-``1``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `mat[][] = {{ ``1``, ``2``, ``3``, ``4``, ``5` `}, ` `                   ``{ ``2``, ``4``, ``5``, ``8``, ``10` `}, ` `                   ``{ ``3``, ``5``, ``7``, ``9``, ``11` `}, ` `                   ``{ ``1``, ``3``, ``5``, ``7``, ``9` `}}; ` `    ``int` `result = findCommon(mat); ` `    ``if` `(result == -``1``) ` `        ``System.out.println(``"No common element"``); ` `    ``else` `        ``System.out.println(``"Common element is "` `+ result); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python

 `# Python3 implementation of the approach ` `from` `collections ``import` `defaultdict ` ` `  `# Specify number of rows and columns ` `M ``=` `4` `N ``=` `5` ` `  `# Returns common element in all rows of ` `# mat[M][N]. If there is no ` `# common element, then -1 is returned ` `def` `findCommon(mat): ` `    ``global` `M ` `    ``global` `N ` ` `  `    ``# A hash map to store count of elements ` `    ``cnt ``=` `dict``() ` `    ``cnt ``=` `defaultdict(``lambda``: ``0``, cnt) ` ` `  `    ``i ``=` `0` `    ``j ``=` `0` ` `  `    ``while` `(i < M ):  ` ` `  `        ``# Increment the count of first ` `        ``# element of the row ` `        ``cnt[mat[i][``0``]] ``=` `cnt[mat[i][``0``]] ``+` `1` ` `  `        ``j ``=` `1` `         `  `        ``# Starting from the second element ` `        ``# of the current row ` `        ``while` `(j < N ) : ` ` `  `            ``# If current element is different from ` `            ``# the previous element i.e. it is appearing ` `            ``# for the first time in the current row ` `            ``if` `(mat[i][j] !``=` `mat[i][j ``-` `1``]): ` `                ``cnt[mat[i][j]] ``=` `cnt[mat[i][j]] ``+` `1` `            ``j ``=` `j ``+` `1` `        ``i ``=` `i ``+` `1` `         `  `    ``# Find element having count equal to number of rows ` `    ``for` `ele ``in` `cnt: ` `        ``if` `(cnt[ele] ``=``=` `M): ` `            ``return` `ele ` `     `  `    ``# No such element found ` `    ``return` `-``1` ` `  `# Driver Code ` `mat ``=` `[[``1``, ``2``, ``3``, ``4``, ``5` `], ` `        ``[``2``, ``4``, ``5``, ``8``, ``10``], ` `        ``[``3``, ``5``, ``7``, ``9``, ``11``], ` `        ``[``1``, ``3``, ``5``, ``7``, ``9` `],] ` `     `  `result ``=` `findCommon(mat) ` `if` `(result ``=``=` `-``1``): ` `    ``print``(``"No common element"``) ` `else``: ` `    ``print``(``"Common element is "``, result) ` ` `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# implementation of the approach ` `using` `System; ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG  ` `{ ` ` `  `// Specify number of rows and columns ` `static` `int` `M = 4; ` `static` `int` `N = 5; ` ` `  `// Returns common element in all rows of mat[M,N]. ` `// If there is no common element, then -1 is returned ` `static` `int` `findCommon(``int` `[,]mat) ` `{ ` `    ``// A hash map to store count of elements ` `    ``Dictionary<``int``, ` `               ``int``> cnt = ``new` `Dictionary<``int``,  ` `                                         ``int``>(); ` ` `  `    ``int` `i, j; ` ` `  `    ``for` `(i = 0; i < M; i++)  ` `    ``{ ` ` `  `        ``// Increment the count of first ` `        ``// element of the row ` `        ``if``(cnt.ContainsKey(mat[i, 0])) ` `        ``{ ` `            ``cnt[mat[i, 0]]= cnt[mat[i, 0]] + 1; ` `        ``} ` `        ``else` `        ``{ ` `            ``cnt.Add(mat[i, 0], 1); ` `        ``} ` ` `  `        ``// Starting from the second element ` `        ``// of the current row ` `        ``for` `(j = 1; j < N; j++)  ` `        ``{ ` ` `  `            ``// If current element is different from ` `            ``// the previous element i.e. it is appearing ` `            ``// for the first time in the current row ` `            ``if` `(mat[i, j] != mat[i, j - 1]) ` `                ``if``(cnt.ContainsKey(mat[i, j])) ` `                ``{ ` `                    ``cnt[mat[i, j]]= cnt[mat[i, j]] + 1; ` `                ``} ` `                ``else` `                ``{ ` `                    ``cnt.Add(mat[i, j], 1); ` `                ``} ` `        ``} ` `    ``} ` ` `  `    ``// Find element having count  ` `    ``// equal to number of rows ` `    ``foreach``(KeyValuePair<``int``, ``int``> ele ``in` `cnt) ` `    ``{ ` `        ``if` `(ele.Value == M) ` `            ``return` `ele.Key; ` `    ``} ` ` `  `    ``// No such element found ` `    ``return` `-1; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `    ``int` `[,]mat = {{ 1, 2, 3, 4, 5 }, ` `                  ``{ 2, 4, 5, 8, 10 }, ` `                  ``{ 3, 5, 7, 9, 11 }, ` `                  ``{ 1, 3, 5, 7, 9 }}; ` `    ``int` `result = findCommon(mat); ` `    ``if` `(result == -1) ` `        ``Console.WriteLine(``"No common element"``); ` `    ``else` `        ``Console.WriteLine(``"Common element is "` `+ result); ` `    ``} ` `}  ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```Common element is 5
```

Time complexity of the above hashing based solution is O(MN) under the assumption that search and insert in HashTable take O(1) time. Thanks to Nishant for suggesting this solution in a comment below.

Exercise: Given n sorted arrays of size m each, find all common elements in all arrays in O(mn) time.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

3

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.