Count number of palindromic path in a matrix

Here given code implementation process.

import java.util.HashMap;
/*
    Java Program for
    Count number of palindromic path in a matrix
*/
class Coordinates
{
	public int sc;
	public int ec;
	public int sr;
	public int er;
	public Coordinates(int sc, int ec, int sr, int er)
	{
		this.sc = sc;
		this.ec = ec;
		this.sr = sr;
		this.er = er;
	}
}
public class PalindromicPath
{
	public int absValue(int value)
	{
		if (value < 0)
		{
			return -value;
		}
		return value;
	}
	public int countPath(char[][] matrix, HashMap < Coordinates, Integer > dp, int sc, int ec, int sr, int er, int n, int m)
	{
		if (sc < 0 || ec < 0 || sr < 0 || er < 0 || 
            sc >= m || ec >= m || sr >= n || er >= n)
		{
			// When index are out of range
			return 0;
		}
		if (sc > ec || sr > er)
		{
			// Overlapping case
			return 0;
		}
		else if (matrix[er][ec] != matrix[sr][sc])
		{
			// When palindrome not exist in given indexes
			return 0;
		}
		else if (absValue((sr - er) + (sc - ec)) <= 1)
		{
			return 1;
		}
		Coordinates point = new Coordinates(sc, ec, sr, er);
		if (dp.containsKey(point))
		{
			// When point already exists
			return dp.get(point);
		}
		// Calculate palindromic path using recursion
		int count = countPath(matrix, dp, sc, ec, sr + 1, er - 1, n, m) + 
          countPath(matrix, dp, sc, ec - 1, sr + 1, er, n, m) + 
          countPath(matrix, dp, sc + 1, ec, sr, er - 1, n, m) + 
          countPath(matrix, dp, sc + 1, ec - 1, sr, er, n, m);
		dp.put(point, count);
		return count;
	}
	// This function are handling the request of counting palindromic path.
	public void countPalindromicPath(char[][] matrix)
	{
		// Get the length
		int n = matrix.length;
		int m = matrix[0].length;
		// Manage coordinates points
		HashMap < Coordinates, Integer > dp = 
          new HashMap < Coordinates, Integer > ();
		int result = countPath(matrix, dp, 0, m - 1, 0, n - 1, n, m);
		System.out.print("\n Result : " + result);
	}
	public static void main(String[] args)
	{
		PalindromicPath task = new PalindromicPath();
		char[][] matrix = {
			{
				'a' , 'a' , 'a' , 'b'
			},
			{
				'b' , 'b' , 'c' , 'b'
			},
			{
				'b' , 'b' , 'c' , 'a'
			},
			{
				'a' , 'a' , 'b' , 'a'
			},
			{
				'a' , 'b' , 'b' , 'a'
			}
		};
		/*
		    a  b  b  a  a  b  b  a
		    a  b  b  a  a  b  b  a
		    a  b  b  a  a  b  b  a
		    a  b  b  c  c  b  b  a
		    a  a  b  c  c  b  a  a
		    a  a  a  c  c  a  a  a
		    a  a  a  b  b  a  a  a
		    --------------------------
		    Result = 7
		*/
		task.countPalindromicPath(matrix);
	}
}

Output

 Result :  7
// Include header file
#include <iostream>
#include <unordered_map>
#define N 5
#define M 4
using namespace std;
/*
    C++ Program for
    Count number of palindromic path in a matrix
*/
class Coordinates
{
    public: int sc;
    int ec;
    int sr;
    int er;
    Coordinates(int sc, int ec, int sr, int er)
    {
        this->sc = sc;
        this->ec = ec;
        this->sr = sr;
        this->er = er;
    }
};
class PalindromicPath
{
    public: int absValue(int value)
    {
        if (value < 0)
        {
            return -value;
        }
        return value;
    }
    int countPath(
        char matrix[N][M], 
        unordered_map <Coordinates*, int > &dp, 
        int sc, 
        int ec, 
        int sr, 
        int er)
    {
        if (sc < 0 || ec < 0 || sr < 0 || er < 0 || sc >= M || 
            ec >= M || sr >= N || er >= N)
        {
            // When index are out of range
            return 0;
        }
        if (sc > ec || sr > er)
        {
            // Overlapping case
            return 0;
        }
        else if (matrix[er][ec] != matrix[sr][sc])
        {
            // When palindrome not exist in given indexes
            return 0;
        }
        else if (this->absValue((sr - er) + (sc - ec)) <= 1)
        {
            return 1;
        }
        Coordinates *point = new Coordinates(sc, ec, sr, er);
        if (dp.find(point) != dp.end())
        {
            // When point already exists
            return dp[point];
        }
        // Calculate palindromic path using recursion
        int count = this->countPath(matrix, dp, sc, ec, sr + 1, er - 1) + 
        this->countPath(matrix, dp, sc, ec - 1, sr + 1, er) + 
        this->countPath(matrix, dp, sc + 1, ec, sr, er - 1) + 
        this->countPath(matrix, dp, sc + 1, ec - 1, sr, er);
        dp[point] = count;
        return count;
    }
    // This function are handling the request of counting palindromic path.
    void countPalindromicPath(char matrix[N][M])
    {
        // Manage coordinates points
        unordered_map <Coordinates*, int > dp;
        int result = this->countPath(matrix, dp, 0, M - 1, 0, N - 1);
        cout << "\n Result : " << result;
    }
};
int main()
{
    PalindromicPath *task = new PalindromicPath();
    char matrix[N][M] = {
        {
            'a' , 'a' , 'a' , 'b'
        } , {
            'b' , 'b' , 'c' , 'b'
        } , {
            'b' , 'b' , 'c' , 'a'
        } , {
            'a' , 'a' , 'b' , 'a'
        } , {
            'a' , 'b' , 'b' , 'a'
        }
    };
    /*
        a  b  b  a  a  b  b  a
        a  b  b  a  a  b  b  a
        a  b  b  a  a  b  b  a
        a  b  b  c  c  b  b  a
        a  a  b  c  c  b  a  a
        a  a  a  c  c  a  a  a
        a  a  a  b  b  a  a  a
        --------------------------
        Result = 7
    */
    task->countPalindromicPath(matrix);
    return 0;
}

Output

 Result : 7
// Include namespace system
using System;
using System.Collections.Generic;
/*
    Csharp Program for
    Count number of palindromic path in a matrix
*/
public class Coordinates
{
	public int sc;
	public int ec;
	public int sr;
	public int er;
	public Coordinates(int sc, int ec, int sr, int er)
	{
		this.sc = sc;
		this.ec = ec;
		this.sr = sr;
		this.er = er;
	}
}
public class PalindromicPath
{
	public int absValue(int value)
	{
		if (value < 0)
		{
			return -value;
		}
		return value;
	}
	public int countPath(
  	char[,] matrix, 
 	Dictionary < Coordinates, int > dp, 
    int sc, int ec, int sr, int er, int n, int m)
	{
		if (sc < 0 || ec < 0 || sr < 0 || er < 0 || 
            sc >= m || ec >= m || sr >= n || er >= n)
		{
			// When index are out of range
			return 0;
		}
		if (sc > ec || sr > er)
		{
			// Overlapping case
			return 0;
		}
		else if (matrix[er,ec] != matrix[sr,sc])
		{
			// When palindrome not exist in given indexes
			return 0;
		}
		else if (this.absValue((sr - er) + (sc - ec)) <= 1)
		{
			return 1;
		}
		Coordinates point = new Coordinates(sc, ec, sr, er);
		if (dp.ContainsKey(point))
		{
			// When point already exists
			return dp[point];
		}
		// Calculate palindromic path using recursion
		int count = this.countPath(matrix, dp, sc, ec, sr + 1, er - 1, n, m) + 
          this.countPath(matrix, dp, sc, ec - 1, sr + 1, er, n, m) + 
          this.countPath(matrix, dp, sc + 1, ec, sr, er - 1, n, m) + 
          this.countPath(matrix, dp, sc + 1, ec - 1, sr, er, n, m);
		dp.Add(point, count);
		return count;
	}
	// This function are handling the request of counting palindromic path.
	public void countPalindromicPath(char[,] matrix)
	{
		// Get the length
		int n = matrix.GetLength(0);
		int m = matrix.GetLength(1);
		// Manage coordinates points
		Dictionary < Coordinates, int > dp = 
          new Dictionary < Coordinates, int > ();
		int result = this.countPath(matrix, dp, 0, m - 1, 0, n - 1, n, m);
		Console.Write("\n Result : " + result);
	}
	public static void Main(String[] args)
	{
		PalindromicPath task = new PalindromicPath();
		char[,] matrix = {
			{
				'a' , 'a' , 'a' , 'b'
			},
			{
				'b' , 'b' , 'c' , 'b'
			},
			{
				'b' , 'b' , 'c' , 'a'
			},
			{
				'a' , 'a' , 'b' , 'a'
			},
			{
				'a' , 'b' , 'b' , 'a'
			}
		};
		/*
		    a  b  b  a  a  b  b  a
		    a  b  b  a  a  b  b  a
		    a  b  b  a  a  b  b  a
		    a  b  b  c  c  b  b  a
		    a  a  b  c  c  b  a  a
		    a  a  a  c  c  a  a  a
		    a  a  a  b  b  a  a  a
		    --------------------------
		    Result = 7
		*/
		task.countPalindromicPath(matrix);
	}
}

Output

 Result : 7
package main
import "fmt"
/*
    Go Program for
    Count number of palindromic path in a matrix
*/
type Coordinates struct {
	sc int
	ec int
	sr int
	er int
}
func getCoordinates(sc int, ec int, sr int, er int) * Coordinates {
	var me *Coordinates = &Coordinates {}
	me.sc = sc
	me.ec = ec
	me.sr = sr
	me.er = er
	return me
}
type PalindromicPath struct {}
func getPalindromicPath() * PalindromicPath {
	var me *PalindromicPath = &PalindromicPath {}
	return me
}
func(this PalindromicPath) absValue(value int) int {
	if value < 0 {
		return -value
	}
	return value
}
func(this PalindromicPath) countPath(matrix[][] byte, 
	dp map[*Coordinates] int, sc int, ec int, 
	sr int, er int, n int, m int) int {
	if sc < 0 || ec < 0 || sr < 0 || er < 0 || sc >= m || 
		ec >= m || sr >= n || er >= n {
		// When index are out of range
		return 0
	}
	if sc > ec || sr > er {
		// Overlapping case
		return 0
	} else if matrix[er][ec] != matrix[sr][sc] {
		// When palindrome not exist in given indexes
		return 0
	} else if this.absValue((sr - er) + (sc - ec)) <= 1 {
		return 1
	}
	var point * Coordinates = getCoordinates(sc, ec, sr, er)
	if _, found := dp[point] ; found {
		// When point already exists
		return dp[point]
	}
	// Calculate palindromic path using recursion
	var count int = this.countPath(matrix, dp, sc, ec, sr + 1, er - 1, n, m) + 
	this.countPath(matrix, dp, sc, ec - 1, sr + 1, er, n, m) + 
	this.countPath(matrix, dp, sc + 1, ec, sr, er - 1, n, m) + 
	this.countPath(matrix, dp, sc + 1, ec - 1, sr, er, n, m)
	dp[point] = count
	return count
}
// This function are handling the request of counting palindromic path.
func(this PalindromicPath) countPalindromicPath(matrix[][] byte) {
	// Get the length
	var n int = len(matrix)
	var m int = len(matrix[0])
	// Manage coordinates points
	var dp = make(map[*Coordinates] int)
	var result int = this.countPath(matrix, dp, 0, m - 1, 0, n - 1, n, m)
	fmt.Print("\n Result : ", result)
}
func main() {
	var task * PalindromicPath = getPalindromicPath()
	var matrix = [][] byte {
		{'a', 'a', 'a', 'b'}, 
        {'b', 'b', 'c', 'b'}, 
        {'b', 'b', 'c', 'a'},
        {'a', 'a', 'b', 'a'},
        {'a', 'b', 'b', 'a'},
     }
	/*
	    a  b  b  a  a  b  b  a
	    a  b  b  a  a  b  b  a
	    a  b  b  a  a  b  b  a
	    a  b  b  c  c  b  b  a
	    a  a  b  c  c  b  a  a
	    a  a  a  c  c  a  a  a
	    a  a  a  b  b  a  a  a
	    --------------------------
	    Result = 7
	*/
	task.countPalindromicPath(matrix)
}

Output

 Result : 7
<?php
/*
    Php Program for
    Count number of palindromic path in a matrix
*/
class Coordinates
{
	public $sc;
	public $ec;
	public $sr;
	public $er;
	public	function __construct($sc, $ec, $sr, $er)
	{
		$this->sc = $sc;
		$this->ec = $ec;
		$this->sr = $sr;
		$this->er = $er;
	}
  	public function getValue()
  	{
      	return $this->sc."-".$this->ec."-".$this->sr."-".$this->er;
  	}
}
class PalindromicPath
{
	public	function absValue($value)
	{
		if ($value < 0)
		{
			return -$value;
		}
		return $value;
	}
	public	function countPath($matrix, &$dp, $sc, $ec, $sr, $er, $n, $m)
	{
		if ($sc < 0 || $ec < 0 || $sr < 0 || $er < 0 || 
            $sc >= $m || $ec >= $m || $sr >= $n || $er >= $n)
		{
			// When index are out of range
			return 0;
		}
		if ($sc > $ec || $sr > $er)
		{
			// Overlapping case
			return 0;
		}
		else if ($matrix[$er][$ec] != $matrix[$sr][$sc])
		{
			// When palindrome not exist in given indexes
			return 0;
		}
		else if ($this->absValue(($sr - $er) + ($sc - $ec)) <= 1)
		{
			return 1;
		}
		$point = new Coordinates($sc, $ec, $sr, $er);
		if (array_key_exists("'".$point->getValue()."'", $dp))
		{
			// When point already exists
			return $dp["'".$point->getValue()."'"];
		}
		// Calculate palindromic path using recursion
		$count = 
          $this->countPath($matrix, $dp, $sc, $ec, $sr + 1, $er - 1, $n, $m) + 
          $this->countPath($matrix, $dp, $sc, $ec - 1, $sr + 1, $er, $n, $m) +
          $this->countPath($matrix, $dp, $sc + 1, $ec, $sr, $er - 1, $n, $m) + 
          $this->countPath($matrix, $dp, $sc + 1, $ec - 1, $sr, $er, $n, $m);
		  $dp["'".$point->getValue()."'"] = $count;
		return $count;
	}
	// This function are handling the request of counting palindromic path.
	public	function countPalindromicPath($matrix)
	{
		// Get the length
		$n = count($matrix);
		$m = count($matrix[0]);
		// Manage coordinates points
		$dp = array();
		$result = $this->countPath($matrix, $dp, 0, $m - 1, 0, $n - 1, $n, $m);
		echo("\n Result : ".$result);
	}
}

function main()
{
	$task = new PalindromicPath();
	$matrix = array(
      array('a', 'a', 'a', 'b'), 
      array('b', 'b', 'c', 'b'), 
      array('b', 'b', 'c', 'a'), 
      array('a', 'a', 'b', 'a'), 
      array('a', 'b', 'b', 'a')
    );
	/*
	    a  b  b  a  a  b  b  a
	    a  b  b  a  a  b  b  a
	    a  b  b  a  a  b  b  a
	    a  b  b  c  c  b  b  a
	    a  a  b  c  c  b  a  a
	    a  a  a  c  c  a  a  a
	    a  a  a  b  b  a  a  a
	    --------------------------
	    Result = 7
	*/
	$task->countPalindromicPath($matrix);
}
main();

Output

 Result : 7
/*
    Node JS Program for
    Count number of palindromic path in a matrix
*/
class Coordinates
{
	constructor(sc, ec, sr, er)
	{
		this.sc = sc;
		this.ec = ec;
		this.sr = sr;
		this.er = er;
	}
}
class PalindromicPath
{
	absValue(value)
	{
		if (value < 0)
		{
			return -value;
		}
		return value;
	}
	countPath(matrix, dp, sc, ec, sr, er, n, m)
	{
		if (sc < 0 || ec < 0 || sr < 0 || er < 0 || 
            sc >= m || ec >= m || sr >= n || er >= n)
		{
			// When index are out of range
			return 0;
		}
		if (sc > ec || sr > er)
		{
			// Overlapping case
			return 0;
		}
		else if (matrix[er][ec] != matrix[sr][sc])
		{
			// When palindrome not exist in given indexes
			return 0;
		}
		else if (this.absValue((sr - er) + (sc - ec)) <= 1)
		{
			return 1;
		}
		var point = new Coordinates(sc, ec, sr, er);
		if (dp.has(point))
		{
			// When point already exists
			return dp.get(point);
		}
		// Calculate palindromic path using recursion
		var count = this.countPath(matrix, dp, sc, ec, sr + 1, er - 1, n, m) + 
            this.countPath(matrix, dp, sc, ec - 1, sr + 1, er, n, m) + 
            this.countPath(matrix, dp, sc + 1, ec, sr, er - 1, n, m) + 
            this.countPath(matrix, dp, sc + 1, ec - 1, sr, er, n, m);
		dp.set(point, count);
		return count;
	}
	// This function are handling the request of counting palindromic path.
	countPalindromicPath(matrix)
	{
		// Get the length
		var n = matrix.length;
		var m = matrix[0].length;
		// Manage coordinates points
		var dp = new Map();
		var result = this.countPath(matrix, dp, 0, m - 1, 0, n - 1, n, m);
		process.stdout.write("\n Result : " + result);
	}
}

function main()
{
	var task = new PalindromicPath();
	var matrix = [
		['a', 'a', 'a', 'b'],
		['b', 'b', 'c', 'b'],
		['b', 'b', 'c', 'a'],
		['a', 'a', 'b', 'a'],
		['a', 'b', 'b', 'a']
	];
	/*
	    a  b  b  a  a  b  b  a
	    a  b  b  a  a  b  b  a
	    a  b  b  a  a  b  b  a
	    a  b  b  c  c  b  b  a
	    a  a  b  c  c  b  a  a
	    a  a  a  c  c  a  a  a
	    a  a  a  b  b  a  a  a
	    --------------------------
	    Result = 7
	*/
	task.countPalindromicPath(matrix);
}
main();

Output

 Result : 7
#    Python 3 Program for
#    Count number of palindromic path in a matrix
class Coordinates :
	def __init__(self, sc, ec, sr, er) :
		self.sc = sc
		self.ec = ec
		self.sr = sr
		self.er = er
	

class PalindromicPath :
	def absValue(self, value) :
		if (value < 0) :
			return -value
		
		return value
	
	def countPath(self, matrix, dp, sc, ec, sr, er, n, m) :
		if (sc < 0 or ec < 0 or sr < 0 or er < 0 or sc >= m or 
            ec >= m or sr >= n or er >= n) :
			#  When index are out of range
			return 0
		
		if (sc > ec or sr > er) :
			#  Overlapping case
			return 0
		elif (matrix[er][ec] != matrix[sr][sc]) :
			#  When palindrome not exist in given indexes
			return 0
		elif (self.absValue((sr - er) + (sc - ec)) <= 1) :
			return 1
		
		point = Coordinates(sc, ec, sr, er)
		if ((point in dp.keys())) :
			#  When point already exists
			return dp.get(point)
		
		#  Calculate palindromic path using recursion
		count = self.countPath(
          matrix, dp, sc, ec, sr + 1, er - 1, n, m
        ) + self.countPath(
          matrix, dp, sc, ec - 1, sr + 1, er, n, m
        ) + self.countPath(
          matrix, dp, sc + 1, ec, sr, er - 1, n, m
        ) + self.countPath(
          matrix, dp, sc + 1, ec - 1, sr, er, n, m
        )
		dp[point] = count
		return count
	
	#  This function are handling the request of counting palindromic path.
	def countPalindromicPath(self, matrix) :
		#  Get the length
		n = len(matrix)
		m = len(matrix[0])
		#  Manage coordinates points
		dp = dict()
		result = self.countPath(matrix, dp, 0, m - 1, 0, n - 1, n, m)
		print("\n Result : ", result, end = "")
	

def main() :
	task = PalindromicPath()
	matrix = [
		['a', 'a', 'a', 'b'],
		['b', 'b', 'c', 'b'],
		['b', 'b', 'c', 'a'],
		['a', 'a', 'b', 'a'],
		['a', 'b', 'b', 'a']
	]
	#    a  b  b  a  a  b  b  a
	#    a  b  b  a  a  b  b  a
	#    a  b  b  a  a  b  b  a
	#    a  b  b  c  c  b  b  a
	#    a  a  b  c  c  b  a  a
	#    a  a  a  c  c  a  a  a
	#    a  a  a  b  b  a  a  a
	#    --------------------------
	#    Result = 7
	task.countPalindromicPath(matrix)

if __name__ == "__main__": main()

Output

 Result :  7
#    Ruby Program for
#    Count number of palindromic path in a matrix
class Coordinates 
	# Define the accessor and reader of class Coordinates
	attr_reader :sc, :ec, :sr, :er
	attr_accessor :sc, :ec, :sr, :er
	def initialize(sc, ec, sr, er) 
		self.sc = sc
		self.ec = ec
		self.sr = sr
		self.er = er
	end

end

class PalindromicPath 
	def absValue(value) 
		if (value < 0) 
			return -value
		end

		return value
	end

	def countPath(matrix, dp, sc, ec, sr, er, n, m) 
		if (sc < 0 || ec < 0 || sr < 0 || er < 0 || 
            sc >= m || ec >= m || sr >= n || er >= n) 
			#  When index are out of range
			return 0
		end

		if (sc > ec || sr > er) 
			#  Overlapping case
			return 0
		elsif (matrix[er][ec] != matrix[sr][sc]) 
			#  When palindrome not exist in given indexes
			return 0
		elsif (self.absValue((sr - er) + (sc - ec)) <= 1) 
			return 1
		end

		point = Coordinates.new(sc, ec, sr, er)
		if (dp.key?(point)) 
			#  When point already exists
			return dp[point]
		end

		#  Calculate palindromic path using recursion
		count = self.countPath(matrix, dp, sc, ec, sr + 1, er - 1, n, m) + 
          self.countPath(matrix, dp, sc, ec - 1, sr + 1, er, n, m) + 
          self.countPath(matrix, dp, sc + 1, ec, sr, er - 1, n, m) + 
          self.countPath(matrix, dp, sc + 1, ec - 1, sr, er, n, m)
		dp[point] = count
		return count
	end

	#  This function are handling the request of counting palindromic path.
	def countPalindromicPath(matrix) 
		#  Get the length
		n = matrix.length
		m = matrix[0].length
		#  Manage coordinates points
		dp = Hash.new()
		result = self.countPath(matrix, dp, 0, m - 1, 0, n - 1, n, m)
		print("\n Result : ", result)
	end

end

def main() 
	task = PalindromicPath.new()
	matrix = [
		['a', 'a', 'a', 'b'],
		['b', 'b', 'c', 'b'],
		['b', 'b', 'c', 'a'],
		['a', 'a', 'b', 'a'],
		['a', 'b', 'b', 'a']
	]
	#    a  b  b  a  a  b  b  a
	#    a  b  b  a  a  b  b  a
	#    a  b  b  a  a  b  b  a
	#    a  b  b  c  c  b  b  a
	#    a  a  b  c  c  b  a  a
	#    a  a  a  c  c  a  a  a
	#    a  a  a  b  b  a  a  a
	#    --------------------------
	#    Result = 7
	task.countPalindromicPath(matrix)
end

main()

Output

 Result : 7
import scala.collection.mutable._;
/*
    Scala Program for
    Count number of palindromic path in a matrix
*/
class Coordinates(var sc: Int,
	var ec: Int,
    var sr: Int,
	var er: Int);
class PalindromicPath()
{
	def absValue(value: Int): Int = {
		if (value < 0)
		{
			return -value;
		}
		return value;
	}
	def countPath(matrix: Array[Array[Char]], 
      dp: HashMap[Coordinates, Int], 
        sc: Int, ec: Int, sr: Int, 
        er: Int, n: Int, m: Int): Int = {
		if (sc < 0 || ec < 0 || sr < 0 || er < 0 || 
             sc >= m || ec >= m || sr >= n || er >= n)
		{
			// When index are out of range
			return 0;
		}
		if (sc > ec || sr > er)
		{
			// Overlapping case
			return 0;
		}
		else if (matrix(er)(ec) != matrix(sr)(sc))
		{
			// When palindrome not exist in given indexes
			return 0;
		}
		else if (absValue((sr - er) + (sc - ec)) <= 1)
		{
			return 1;
		}
		var point: Coordinates = new Coordinates(sc, ec, sr, er);
		if (dp.contains(point))
		{
			// When point already exists
			return dp.get(point).get;
		}
		// Calculate palindromic path using recursion
		var count: Int = countPath(matrix, dp, sc, ec, sr + 1, er - 1, n, m) + 
          countPath(matrix, dp, sc, ec - 1, sr + 1, er, n, m) + 
          countPath(matrix, dp, sc + 1, ec, sr, er - 1, n, m) + 
          countPath(matrix, dp, sc + 1, ec - 1, sr, er, n, m);
		dp.addOne(point, count);
		return count;
	}
	// This function are handling the request of counting palindromic path.
	def countPalindromicPath(matrix: Array[Array[Char]]): Unit = {
		// Get the length
		var n: Int = matrix.length;
		var m: Int = matrix(0).length;
		// Manage coordinates points
		var dp: HashMap[Coordinates, Int] = new HashMap[Coordinates, Int]();
		var result: Int = countPath(matrix, dp, 0, m - 1, 0, n - 1, n, m);
		print("\n Result : " + result);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: PalindromicPath = new PalindromicPath();
		var matrix: Array[Array[Char]] = Array(
          Array('a', 'a', 'a', 'b'), 
          Array('b', 'b', 'c', 'b'), 
          Array('b', 'b', 'c', 'a'), 
          Array('a', 'a', 'b', 'a'), 
          Array('a', 'b', 'b', 'a')
        );
		/*
		    a  b  b  a  a  b  b  a
		    a  b  b  a  a  b  b  a
		    a  b  b  a  a  b  b  a
		    a  b  b  c  c  b  b  a
		    a  a  b  c  c  b  a  a
		    a  a  a  c  c  a  a  a
		    a  a  a  b  b  a  a  a
		    --------------------------
		    Result = 7
		*/
		task.countPalindromicPath(matrix);
	}
}

Output

 Result : 7
/*
    Kotlin Program for
    Count number of palindromic path in a matrix
*/
class Coordinates
{
	var sc: Int;
	var ec: Int;
	var sr: Int;
	var er: Int;
	constructor(sc: Int, ec: Int, sr: Int, er: Int)
	{
		this.sc = sc;
		this.ec = ec;
		this.sr = sr;
		this.er = er;
	}
}
class PalindromicPath
{
	fun absValue(value: Int): Int
	{
		if (value < 0)
		{
			return -value;
		}
		return value;
	}
	fun countPath(
      matrix: Array < Array < Char >> , 
      dp: HashMap < Coordinates, Int >  , 
      sc : Int, ec: Int, sr: Int, 
      er: Int, n: Int, m: Int): Int
	{
		if (sc < 0 || ec < 0 || sr < 0 || er < 0 ||
            sc >= m || ec >= m || sr >= n || er >= n)
		{
			// When index are out of range
			return 0;
		}
		if (sc > ec || sr > er)
		{
			// Overlapping case
			return 0;
		}
		else if (matrix[er][ec] != matrix[sr][sc])
		{
			// When palindrome not exist in given indexes
			return 0;
		}
		else if (this.absValue((sr - er) + (sc - ec)) <= 1)
		{
			return 1;
		}
		val point: Coordinates = Coordinates(sc, ec, sr, er);
		if (dp.containsKey(point))
		{
			// When point already exists
			return dp.getValue(point);
		}
		// Calculate palindromic path using recursion
		val count: Int = 
          this.countPath(matrix, dp, sc, ec, sr + 1, er - 1, n, m) + 
          this.countPath(matrix, dp, sc, ec - 1, sr + 1, er, n, m) + 
          this.countPath(matrix, dp, sc + 1, ec, sr, er - 1, n, m) + 
          this.countPath(matrix, dp, sc + 1, ec - 1, sr, er, n, m);
		dp.put(point, count);
		return count;
	}
	// This function are handling the request of counting palindromic path.
	fun countPalindromicPath(matrix: Array < Array < Char >> ): Unit
	{
		// Get the length
		val n: Int = matrix.count();
		val m: Int = matrix[0].count();
		// Manage coordinates points
		val dp: HashMap < Coordinates, Int > = HashMap < Coordinates, Int > ();
		val result: Int = this.countPath(matrix, dp, 0, m - 1, 0, n - 1, n, m);
		print("\n Result : " + result);
	}
}
fun main(args: Array < String > ): Unit
{
	val task: PalindromicPath = PalindromicPath();
	val matrix: Array < Array < Char >> = arrayOf(
      arrayOf('a', 'a', 'a', 'b'), 
      arrayOf('b', 'b', 'c', 'b'), 
      arrayOf('b', 'b', 'c', 'a'), 
      arrayOf('a', 'a', 'b', 'a'), 
      arrayOf('a', 'b', 'b', 'a')
    );
	/*
	    a  b  b  a  a  b  b  a
	    a  b  b  a  a  b  b  a
	    a  b  b  a  a  b  b  a
	    a  b  b  c  c  b  b  a
	    a  a  b  c  c  b  a  a
	    a  a  a  c  c  a  a  a
	    a  a  a  b  b  a  a  a
	    --------------------------
	    Result = 7
	*/
	task.countPalindromicPath(matrix);
}

Output

 Result : 7


Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment







© 2021, kalkicode.com, All rights reserved