# Count of odd length contiguous Palindromic sequences in a Matrix

Given a matrix arr[][] of size MxN, the task is to find the number of contiguous palindromic sequences of odd length in that matrix.

Example:

```Input: arr[][] = { { 2, 1, 2 },
{ 1, 1, 1 },
{ 2, 1, 2 }}
Output: 15
Explanation
Contigiuos Palindromic sequences of odd length are:
Row 1: (2), (1), (2), (2, 1, 2) => n(R1) = 4
Row 2: (1), (1), (1), (1, 1, 1) => n(R2) = 4
Row 3: (2), (1), (2), (2, 1, 2) => n(R3) = 4
Column 1: (2, 1, 2) => n(C1) = 1
Column 2: (1, 1, 1) => n(C2) = 1
Column 3: (2, 1, 2) => n(C3) = 1
Therefore,
Total count = n(R1) + n(R2) + n(R3)
+ n(C1) + n(C2) + n(C3)
= 15

Input: arr[][] = { { 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1 },
{ 1, 1, 1, 1, 1 } }
Output: 65
```

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

Approach:

1. Create a variable count to store the total number of contiguous palindromic sequences in the matrix
2. As each element in the matrix is a contiguous Palindromic sequence of length 1, add the total number of elements in the matrix to the count, i, e,
`count += (M*N)`
3. Then for the sequence of length > 1,
• Iterate through each element of the matrix and count the number of palindromic sequences in each row by comparing the elements to the other elements on it’s left and right
• Similarly count the number of palindromic sequences in each column by comparing the elements to the other elements on its above and below.
4. If found, increment the count of found palindromic sequences by 1.
5. Print the computed count of palindromic sequences in the end

Below is the implementation of the above approach:

## C++

 `// C++ code to Count the odd length contiguous ` `// Palindromic sequences in the matrix ` ` `  `#include ` `using` `namespace` `std; ` ` `  `#define MAX 10 ` ` `  `// Function to count the number of ` `// contiguous palindromic sequences in the matrix ` `int` `countPalindromes(``int` `n, ``int` `m, ``int` `matrix[MAX][MAX]) ` `{ ` `    ``// Add the total number of elements ` `    ``// in the matrix to the count ` `    ``int` `count = n * m; ` ` `  `    ``// Length of possible sequence to be checked ` `    ``// for palindrome horizontally and vertically ` `    ``int` `length_of_sequence_row; ` `    ``int` `length_of_sequence_column; ` ` `  `    ``// Iterate through each element of the matrix ` `    ``// and count the number of palindromic ` `    ``// sequences in each row and column ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``for` `(``int` `j = 0; j < m; j++) { ` ` `  `            ``// Find the possible length of sequences ` `            ``// that can be a palindrome ` `            ``length_of_sequence_row ` `                ``= min(j, m - 1 - j); ` `            ``length_of_sequence_column ` `                ``= min(i, n - i - 1); ` ` `  `            ``// From i, check if the sequence ` `            ``// formed by elements to its ` `            ``// left and right is ` `            ``// palindrome or not ` `            ``for` `(``int` `k = 1; k <= length_of_sequence_row; k++) { ` ` `  `                ``// if the sequence [i, j-k] to [i, j+k] ` `                ``// is a palindrome, ` `                ``// increment the count by 1 ` `                ``if` `(matrix[i][j - k] == matrix[i][j + k]) { ` `                    ``count++; ` `                ``} ` `                ``else` `{ ` `                    ``break``; ` `                ``} ` `            ``} ` ` `  `            ``// From i, check if the sequence ` `            ``// formed by elements to its ` `            ``// above and below is ` `            ``// palindrome or not ` `            ``for` `(``int` `k = 1; k <= length_of_sequence_column; k++) { ` ` `  `                ``// if the sequence [i-k, j] to [i+k, j] ` `                ``// is a palindrome, ` `                ``// increment the count by 1 ` `                ``if` `(matrix[i - k][j] == matrix[i + k][j]) { ` `                    ``count++; ` `                ``} ` `                ``else` `{ ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Return the total count ` `    ``// of the palindromic sequences ` `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main(``void``) ` `{ ` `    ``int` `m = 3, n = 3; ` `    ``int` `matrix[MAX][MAX] = { { 2, 1, 2 }, ` `                             ``{ 1, 1, 1 }, ` `                             ``{ 2, 1, 2 } }; ` ` `  `    ``cout << countPalindromes(n, m, matrix) ` `         ``<< endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java code to Count the odd length contiguous ` `// Palindromic sequences in the matrix ` `class` `GFG ` `{ ` ` `  `static` `final` `int` `MAX = ``10``; ` ` `  `// Function to count the number of ` `// contiguous palindromic sequences in the matrix ` `static` `int` `countPalindromes(``int` `n, ``int` `m, ``int` `matrix[][]) ` `{ ` `    ``// Add the total number of elements ` `    ``// in the matrix to the count ` `    ``int` `count = n * m; ` ` `  `    ``// Length of possible sequence to be checked ` `    ``// for palindrome horizontally and vertically ` `    ``int` `length_of_sequence_row; ` `    ``int` `length_of_sequence_column; ` ` `  `    ``// Iterate through each element of the matrix ` `    ``// and count the number of palindromic ` `    ``// sequences in each row and column ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``for` `(``int` `j = ``0``; j < m; j++)  ` `        ``{ ` ` `  `            ``// Find the possible length of sequences ` `            ``// that can be a palindrome ` `            ``length_of_sequence_row ` `                ``= Math.min(j, m - ``1` `- j); ` `            ``length_of_sequence_column ` `                ``= Math.min(i, n - i - ``1``); ` ` `  `            ``// From i, check if the sequence ` `            ``// formed by elements to its ` `            ``// left and right is ` `            ``// palindrome or not ` `            ``for` `(``int` `k = ``1``; k <= length_of_sequence_row; k++) ` `            ``{ ` ` `  `                ``// if the sequence [i, j-k] to [i, j+k] ` `                ``// is a palindrome, ` `                ``// increment the count by 1 ` `                ``if` `(matrix[i][j - k] == matrix[i][j + k])  ` `                ``{ ` `                    ``count++; ` `                ``} ` `                ``else` `                ``{ ` `                    ``break``; ` `                ``} ` `            ``} ` ` `  `            ``// From i, check if the sequence ` `            ``// formed by elements to its ` `            ``// above and below is ` `            ``// palindrome or not ` `            ``for` `(``int` `k = ``1``; k <= length_of_sequence_column; k++) ` `            ``{ ` ` `  `                ``// if the sequence [i-k, j] to [i+k, j] ` `                ``// is a palindrome, ` `                ``// increment the count by 1 ` `                ``if` `(matrix[i - k][j] == matrix[i + k][j])  ` `                ``{ ` `                    ``count++; ` `                ``} ` `                ``else` `                ``{ ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Return the total count ` `    ``// of the palindromic sequences ` `    ``return` `count; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String []args) ` `{ ` `    ``int` `m = ``3``, n = ``3``; ` `    ``int` `matrix[][] = { { ``2``, ``1``, ``2` `}, ` `                        ``{ ``1``, ``1``, ``1` `}, ` `                        ``{ ``2``, ``1``, ``2` `} }; ` ` `  `    ``System.out.print(countPalindromes(n, m, matrix) ` `        ``+``"\n"``); ` ` `  `} ` `} ` ` `  `// This code is contributed by 29AjayKumar ` `` `

## Python3

 `# Python code to Count the odd length contiguous ` `# Palindromic sequences in the matrix ` `MAX` `=` `10``; ` ` `  `# Function to count the number of ` `# contiguous palindromic sequences in the matrix ` `def` `countPalindromes(n, m, matrix): ` ` `  `    ``# Add the total number of elements ` `    ``# in the matrix to the count ` `    ``count ``=` `n ``*` `m; ` ` `  `    ``# Length of possible sequence to be checked ` `    ``# for palindrome horizontally and vertically ` `    ``length_of_sequence_row ``=` `0``; ` `    ``length_of_sequence_column ``=` `0``; ` ` `  `    ``# Iterate through each element of the matrix ` `    ``# and count the number of palindromic ` `    ``# sequences in each row and column ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(m): ` ` `  `            ``# Find the possible length of sequences ` `            ``# that can be a palindrome ` `            ``length_of_sequence_row ``=` `min``(j, m ``-` `1` `-` `j); ` `            ``length_of_sequence_column ``=` `min``(i, n ``-` `i ``-` `1``); ` ` `  `            ``# From i, check if the sequence ` `            ``# formed by elements to its ` `            ``# left and right is ` `            ``# palindrome or not ` `            ``for` `k ``in` `range``(``1``, length_of_sequence_row ``+` `1``): ` ` `  `                ``# if the sequence [i, j-k] to [i, j+k] ` `                ``# is a palindrome, ` `                ``# increment the count by 1 ` `                ``if` `(matrix[i][j ``-` `k] ``=``=` `matrix[i][j ``+` `k]): ` `                    ``count ``+``=` `1``; ` `                ``else``: ` `                    ``break``; ` `                 `  `            ``# From i, check if the sequence ` `            ``# formed by elements to its ` `            ``# above and below is ` `            ``# palindrome or not ` `            ``for` `k ``in` `range``(``1``, length_of_sequence_column ``+` `1``): ` ` `  `                ``# if the sequence [i-k, j] to [i+k, j] ` `                ``# is a palindrome, ` `                ``# increment the count by 1 ` `                ``if` `(matrix[i ``-` `k][j] ``=``=` `matrix[i ``+` `k][j]): ` `                    ``count ``+``=` `1``; ` `                ``else``: ` `                    ``break``; ` `                 `  `    ``# Return the total count ` `    ``# of the palindromic sequences ` `    ``return` `count; ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``m ``=` `3``; ` `    ``n ``=` `3``; ` `    ``matrix ``=` `[ ``2``, ``1``, ``2` `],[ ``1``, ``1``, ``1` `],[ ``2``, ``1``, ``2` `]; ` ` `  `    ``print``(countPalindromes(n, m, matrix)); ` ` `  `# This code is contributed by 29AjayKumar `

## C#

 `// C# code to Count the odd length contiguous  ` `// Palindromic sequences in the matrix  ` `using` `System; ` ` `  `class` `GFG  ` `{  ` ` `  `    ``static` `int` `MAX = 10;  ` `     `  `    ``// Function to count the number of  ` `    ``// contiguous palindromic sequences in the matrix  ` `    ``static` `int` `countPalindromes(``int` `n, ``int` `m, ``int` `[,]matrix)  ` `    ``{  ` `        ``// Add the total number of elements  ` `        ``// in the matrix to the count  ` `        ``int` `count = n * m;  ` `     `  `        ``// Length of possible sequence to be checked  ` `        ``// for palindrome horizontally and vertically  ` `        ``int` `length_of_sequence_row;  ` `        ``int` `length_of_sequence_column;  ` `     `  `        ``// Iterate through each element of the matrix  ` `        ``// and count the number of palindromic  ` `        ``// sequences in each row and column  ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{  ` `            ``for` `(``int` `j = 0; j < m; j++)  ` `            ``{  ` `     `  `                ``// Find the possible length of sequences  ` `                ``// that can be a palindrome  ` `                ``length_of_sequence_row  ` `                    ``= Math.Min(j, m - 1 - j);  ` `                ``length_of_sequence_column  ` `                    ``= Math.Min(i, n - i - 1);  ` `     `  `                ``// From i, check if the sequence  ` `                ``// formed by elements to its  ` `                ``// left and right is  ` `                ``// palindrome or not  ` `                ``for` `(``int` `k = 1; k <= length_of_sequence_row; k++)  ` `                ``{  ` `     `  `                    ``// if the sequence [i, j-k] to [i, j+k]  ` `                    ``// is a palindrome,  ` `                    ``// increment the count by 1  ` `                    ``if` `(matrix[i, j - k] == matrix[i, j + k])  ` `                    ``{  ` `                        ``count++;  ` `                    ``}  ` `                    ``else` `                    ``{  ` `                        ``break``;  ` `                    ``}  ` `                ``}  ` `     `  `                ``// From i, check if the sequence  ` `                ``// formed by elements to its  ` `                ``// above and below is  ` `                ``// palindrome or not  ` `                ``for` `(``int` `k = 1; k <= length_of_sequence_column; k++)  ` `                ``{  ` `     `  `                    ``// if the sequence [i-k, j] to [i+k, j]  ` `                    ``// is a palindrome,  ` `                    ``// increment the count by 1  ` `                    ``if` `(matrix[i - k, j] == matrix[i + k, j])  ` `                    ``{  ` `                        ``count++;  ` `                    ``}  ` `                    ``else` `                    ``{  ` `                        ``break``;  ` `                    ``}  ` `                ``}  ` `            ``}  ` `        ``}  ` `     `  `        ``// Return the total count  ` `        ``// of the palindromic sequences  ` `        ``return` `count;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main()  ` `    ``{  ` `        ``int` `m = 3, n = 3;  ` `        ``int` `[,]matrix = { { 2, 1, 2 },  ` `                            ``{ 1, 1, 1 },  ` `                            ``{ 2, 1, 2 } };  ` `     `  `        ``Console.WriteLine(countPalindromes(n, m, matrix) );  ` `    ``}  ` `}  ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```15
```

Time Complexity: O(n*m*max(n, m))

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 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.

Improved By : 29AjayKumar, AnkitRai01