# Find the count of mountains in a given Matrix

Given a 2D square matrix of size N X N, the task is to count the number of mountains in the matrix.

An element in a matrix is said to be a mountain when all the surrounding elements (in all 8 directions) are smaller than the given element.

Examples:

```Input: matrix =
{ { 4, 5, 6 },
{ 2, 1, 3 },
{ 7, 8, 9 } }
Output: 1
Explanation
Only mountain element = 9.
All the neighbouring elements
1, 3 and 8 are smaller than 9.

Input: matrix =
{ { 7, 8, 9 },
{ 1, 2, 3 },
{ 4, 5, 6 } }
Output: 2
Explanation
Mountain elements = 6 (2, 3 and 5)
and 9 (8, 2, and 3)
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to iterate through the matrix and at the same time check neighbouring elements in all possible 8 directions. If the element is greater than all of them then increment the counter variable. Finally, return the counter.

1. Create an auxiliary array of size (N + 2) X (N + 2).
2. Fill all the border elements with INT_MIN value
3. In the remaining array space of N X N, copy the original matrix
4. Now check if an element is greater than the elements in all the 8 directions.
5. Count the number of such elements and print it.

For example:

```If matrix =
{ { 7, 8, 9 },
{ 1, 2, 3 },
{ 4, 5, 6 } }

The auxiliary array would be
{ { 0, 0, 0, 0, 0 },
{ 0, 7, 8, 9, 0 },
{ 0, 1, 2, 3, 0 },
{ 0, 4, 5, 6, 0 },
{ 0, 0, 0, 0, 0 } }
```

Below is the implementation of above approach :

## C++

 `// C++ program find the count of ` `// mountains in a given Matrix ` ` `  `#include ` `using` `namespace` `std; ` ` `  `const` `int` `MAX = 100; ` ` `  `// Function to count number of mountains ` `// in a given matrix of size n ` `int` `countMountains(``int` `a[][MAX], ``int` `n) ` `{ ` `    ``int` `A[n + 2][n + 2]; ` `    ``int` `count = 0; ` ` `  `    ``// form another matrix with one extra ` `    ``// layer of border elements. Border ` `    ``// elements will contain INT_MIN value. ` `    ``for` `(``int` `i = 0; i < n + 2; i++) { ` `        ``for` `(``int` `j = 0; j < n + 2; j++) { ` ` `  `            ``if` `((i == 0) || (j == 0) ` `                ``|| (i == n + 1) ` `                ``|| (j == n + 1)) { ` ` `  `                ``// For border elements, ` `                ``// set value as INT_MIN ` `                ``A[i][j] = INT_MIN; ` `            ``} ` `            ``else` `{ ` ` `  `                ``// For rest elements, just copy ` `                ``// it into new matrix ` `                ``A[i][j] = a[i - 1][j - 1]; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Check for mountains in the modified matrix ` `    ``for` `(``int` `i = 1; i <= n; i++) { ` `        ``for` `(``int` `j = 1; j <= n; j++) { ` ` `  `            ``// check for all directions ` `            ``if` `((A[i][j] > A[i - 1][j]) ` `                ``&& (A[i][j] > A[i + 1][j]) ` `                ``&& (A[i][j] > A[i][j - 1]) ` `                ``&& (A[i][j] > A[i][j + 1]) ` `                ``&& (A[i][j] > A[i - 1][j - 1]) ` `                ``&& (A[i][j] > A[i + 1][j + 1]) ` `                ``&& (A[i][j] > A[i - 1][j + 1]) ` `                ``&& (A[i][j] > A[i + 1][j - 1])) { ` `                ``count++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a[][MAX] = { { 1, 2, 3 }, ` `                     ``{ 4, 5, 6 }, ` `                     ``{ 7, 8, 9 } }; ` `    ``int` `n = 3; ` ` `  `    ``cout << countMountains(a, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program find the count of ` `// mountains in a given Matrix ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `  `  `static` `int` `MAX = ``100``; ` `  `  `// Function to count number of mountains ` `// in a given matrix of size n ` `static` `int` `countMountains(``int` `a[][], ``int` `n) ` `{ ` `    ``int` `[][]A = ``new` `int``[n + ``2``][n + ``2``]; ` `    ``int` `count = ``0``; ` `  `  `    ``// form another matrix with one extra ` `    ``// layer of border elements. Border ` `    ``// elements will contain Integer.MIN_VALUE value. ` `    ``for` `(``int` `i = ``0``; i < n + ``2``; i++) { ` `        ``for` `(``int` `j = ``0``; j < n + ``2``; j++) { ` `  `  `            ``if` `((i == ``0``) || (j == ``0``) ` `                ``|| (i == n + ``1``) ` `                ``|| (j == n + ``1``)) { ` `  `  `                ``// For border elements, ` `                ``// set value as Integer.MIN_VALUE ` `                ``A[i][j] = Integer.MIN_VALUE; ` `            ``} ` `            ``else` `{ ` `  `  `                ``// For rest elements, just copy ` `                ``// it into new matrix ` `                ``A[i][j] = a[i - ``1``][j - ``1``]; ` `            ``} ` `        ``} ` `    ``} ` `  `  `    ``// Check for mountains in the modified matrix ` `    ``for` `(``int` `i = ``1``; i <= n; i++) { ` `        ``for` `(``int` `j = ``1``; j <= n; j++) { ` `  `  `            ``// check for all directions ` `            ``if` `((A[i][j] > A[i - ``1``][j]) ` `                ``&& (A[i][j] > A[i + ``1``][j]) ` `                ``&& (A[i][j] > A[i][j - ``1``]) ` `                ``&& (A[i][j] > A[i][j + ``1``]) ` `                ``&& (A[i][j] > A[i - ``1``][j - ``1``]) ` `                ``&& (A[i][j] > A[i + ``1``][j + ``1``]) ` `                ``&& (A[i][j] > A[i - ``1``][j + ``1``]) ` `                ``&& (A[i][j] > A[i + ``1``][j - ``1``])) { ` `                ``count++; ` `            ``} ` `        ``} ` `    ``} ` `  `  `    ``return` `count; ` `} ` `  `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `a[][] = { { ``1``, ``2``, ``3` `}, ` `                     ``{ ``4``, ``5``, ``6` `}, ` `                     ``{ ``7``, ``8``, ``9` `} }; ` `    ``int` `n = ``3``; ` `  `  `    ``System.out.print(countMountains(a, n)); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

## Python3

 `# Python3 program find the count of ` `# mountains in a given Matrix ` `MAX` `=` `100` ` `  `# Function to count number of mountains ` `# in a given matrix of size n ` `def` `countMountains(a, n): ` `    ``A ``=` `[[``0` `for` `i ``in` `range``(n``+``2``)] ``for` `i ``in` `range``(n``+``2``)] ` `    ``count ``=` `0` ` `  `    ``# form another matrix with one extra ` `    ``# layer of border elements. Border ` `    ``# elements will contain INT_MIN value. ` `    ``for` `i ``in` `range``(n``+``2``): ` `        ``for` `j ``in` `range``(n``+``2``):  ` `            ``if` `((i ``=``=` `0``) ``or` `(j ``=``=` `0``) ``or`  `                ``(i ``=``=` `n ``+` `1``) ``or` `(j ``=``=` `n ``+` `1``)): ` ` `  `                ``# For border elements, ` `                ``# set value as INT_MIN ` `                ``A[i][j] ``=` `float``(``'-inf'``) ` `            ``else``: ` ` `  `                ``# For rest elements, just copy ` `                ``# it into new matrix ` `                ``A[i][j] ``=` `a[i ``-` `1``][j ``-` `1``] ` `             `  `    ``# Check for mountains in the modified matrix ` `    ``for` `i ``in` `range``(n ``+` `1``): ` `        ``for` `j ``in` `range``(n ``+` `1``):  ` `            ``if` `((A[i][j] > A[i ``-` `1``][j]) ``and`  `                ``(A[i][j] > A[i ``+` `1``][j]) ``and`  `                ``(A[i][j] > A[i][j ``-` `1``]) ``and`  `                ``(A[i][j] > A[i][j ``+` `1``]) ``and`  `                ``(A[i][j] > A[i ``-` `1``][j ``-` `1``]) ``and`  `                ``(A[i][j] > A[i ``+` `1``][j ``+` `1``]) ``and`  `                ``(A[i][j] > A[i ``-` `1``][j ``+` `1``]) ``and`  `                ``(A[i][j] > A[i ``+` `1``][j ``-` `1``])): ` `                ``count ``=` `count ``+` `1` ` `  `    ``return` `count ` ` `  `# Driver code ` `a ``=` `[ [ ``1``, ``2``, ``3` `], ` `    ``[ ``4``, ``5``, ``6` `], ` `    ``[ ``7``, ``8``, ``9` `] ] ` ` `  `n ``=` `3` ` `  `print``(countMountains(a, n)) ` ` `  `# This code is contributed by Sanjit_Prasad `

## C#

 `// C# program find the count of  ` `// mountains in a given Matrix  ` `using` `System; ` ` `  `class` `GFG{  ` ` `  `    ``static` `int` `MAX = 100;  ` `     `  `    ``// Function to count number of mountains  ` `    ``// in a given matrix of size n  ` `    ``static` `int` `countMountains(``int` `[,]a, ``int` `n)  ` `    ``{  ` `        ``int` `[,]A = ``new` `int``[n + 2,n + 2];  ` `        ``int` `count = 0;  ` `     `  `        ``// form another matrix with one extra  ` `        ``// layer of border elements. Border  ` `        ``// elements will contain Integer.MIN_VALUE value.  ` `        ``for` `(``int` `i = 0; i < n + 2; i++) {  ` `            ``for` `(``int` `j = 0; j < n + 2; j++) {  ` `     `  `                ``if` `((i == 0) || (j == 0)  ` `                    ``|| (i == n + 1)  ` `                    ``|| (j == n + 1)) {  ` `     `  `                    ``// For border elements,  ` `                    ``// set value as Integer.MIN_VALUE  ` `                    ``A[i,j] = ``int``.MinValue;  ` `                ``}  ` `                ``else` `{  ` `     `  `                    ``// For rest elements, just copy  ` `                    ``// it into new matrix  ` `                    ``A[i,j] = a[i - 1,j - 1];  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``// Check for mountains in the modified matrix  ` `        ``for` `(``int` `i = 1; i <= n; i++) {  ` `            ``for` `(``int` `j = 1; j <= n; j++) {  ` `     `  `                ``// check for all directions  ` `                ``if` `((A[i,j] > A[i - 1,j])  ` `                    ``&& (A[i,j] > A[i + 1,j])  ` `                    ``&& (A[i,j] > A[i,j - 1])  ` `                    ``&& (A[i,j] > A[i,j + 1])  ` `                    ``&& (A[i,j] > A[i - 1,j - 1])  ` `                    ``&& (A[i,j] > A[i + 1,j + 1])  ` `                    ``&& (A[i,j] > A[i - 1,j + 1])  ` `                    ``&& (A[i,j] > A[i + 1,j - 1])) {  ` `                    ``count++;  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``return` `count;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(``string``[] args)  ` `    ``{  ` `        ``int` `[,]a = { { 1, 2, 3 },  ` `                        ``{ 4, 5, 6 },  ` `                        ``{ 7, 8, 9 } };  ` `        ``int` `n = 3;  ` `     `  `        ``Console.WriteLine(countMountains(a, n));  ` `    ``}  ` `}  ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```1
```

Performance Analysis:

• Time Complexity: In the above approach, we are doing two iterations. First one is on (N + 2) X (N + 2) elements to create the auxiliary matrix. Second one on N X N elements to find actual mountain element, so the time complexity is O(N X N).
• Auxiliary Space Complexity: In the above approach, we are using an auxiliary matrix of size (N + 2) X (N + 2), so Auxiliary space complexity is O(N *N).

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.