# Count of all possible ways to reach a target by a Knight

Given two integers N, M denoting N×M chessboard, the task is to count the number of ways a knight can reach (N, M) starting from (0, 0). Since the answer can be very large, print the answer modulo 109+7.

Example:

Input: N =3, M= 3
Output: 2
Explanation:
Two ways to reach (3, 3) form (0, 0) are as follows:
(0, 0) → (1, 2) → (3, 3)
(0, 0) → (2, 1) → (3, 3)

Input: N=4, M=3
Output: 0
Explanation: No possible way exists to reach (4, 3) form (0, 0).

Approach: Idea here is to observe the pattern that each move increments the value of the x-coordinate + value of y-coordinate by 3. Follow the steps below to solve the problem.

1. If (N + M) is not divisible by 3 then no possible path exists.
2. If (N + M) % 3==0 then count the number of moves of type (+1, +2) i.e, X and count the number of moves of type (+2, +1) i.e, Y.
3. Find the equation of the type (+1, +2) i.e. X + 2Y = N
4. Find the equation of the type (+2, +1) i.e. 2X + Y = M
5. Find the calculated values of X and Y, if X < 0 or Y < 0, then no possible path exists.
6. Otherwise, calculate (X+Y)CY.

Below is the implementation of the above approach:

## C++14

 `// C++ Program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `const` `int` `Mod = 1e9 + 7; ` ` `  `// Function to return X^Y % Mod ` `int` `power(``int` `X, ``int` `Y, ``int` `Mod) ` `{ ` ` `  `    ``// Base Case ` `    ``if` `(Y == 0) ` `        ``return` `1; ` ` `  `    ``int` `p = power(X, Y / 2, Mod) % Mod; ` `    ``p = (p * p) % Mod; ` ` `  `    ``if` `(Y & 1) { ` `        ``p = (X * p) % Mod; ` `    ``} ` ` `  `    ``return` `p; ` `} ` ` `  `// Function to return the ` `// inverse of factorial of N ` `int` `Inversefactorial(``int` `N) ` `{ ` ` `  `    ``// Base case ` `    ``if` `(N <= 0) ` `        ``return` `1; ` ` `  `    ``int` `fact = 1; ` ` `  `    ``for` `(``int` `i = 1; i <= N; i++) { ` `        ``fact = (fact * i) % Mod; ` `    ``} ` ` `  `    ``return` `power(fact, Mod - 2, Mod); ` `} ` ` `  `// Function to return factorial ` `// of n % Mod ` `int` `factorial(``int` `N) ` `{ ` ` `  `    ``// Base case ` `    ``if` `(N <= 0) ` `        ``return` `1; ` ` `  `    ``int` `fact = 1; ` ` `  `    ``for` `(``int` `i = 1; i <= N; i++) { ` `        ``fact = (fact * i) % Mod; ` `    ``} ` ` `  `    ``return` `fact; ` `} ` ` `  `// Function to return  the value ` `// of n! / (( n- k)! * k!) ` `int` `nck(``int` `N, ``int` `K) ` `{ ` `    ``int` `factN = factorial(N); ` `    ``int` `inv = Inversefactorial(K); ` `    ``int` `invFact = Inversefactorial(N - K); ` `    ``return` `(((factN * inv) % Mod) * invFact) % Mod; ` `} ` ` `  `// Function to return the count of ` `// ways to reach (n, m) from (0, 0) ` `int` `TotalWaYs(``int` `N, ``int` `M) ` `{ ` ` `  `    ``// If (N + M) % 3 != 0 ` `    ``if` `((N + M) % 3 != 0) ` ` `  `        ``// No possible way exists ` `        ``return` `0; ` ` `  `    ``// Calculate X and Y from the ` `    ``// equations X + 2Y = N ` `    ``// and 2X + Y == M ` `    ``int` `X = N - (N + M) / 3; ` `    ``int` `Y = M - (N + M) / 3; ` ` `  `    ``if` `(X < 0 || Y < 0) ` `        ``return` `0; ` ` `  `    ``return` `nck(X + Y, Y); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `    ``int` `N = 3, M = 3; ` ` `  `    ``cout << TotalWaYs(N, M); ` ` `  `    ``return` `0; ` `}`

## Java

 `// Java Program to implement ` `// the above approach ` `import` `java.util.*; ` `class` `GFG{ ` ` `  `static` `int` `Mod = (``int``) (1e9 + ``7``); ` ` `  `// Function to return X^Y % Mod ` `static` `int` `power(``int` `X, ``int` `Y, ``int` `Mod) ` `{ ` ` `  `    ``// Base Case ` `    ``if` `(Y == ``0``) ` `        ``return` `1``; ` ` `  `    ``int` `p = power(X, Y / ``2``, Mod) % Mod; ` `    ``p = (p * p) % Mod; ` ` `  `    ``if` `((Y & ``1``) != ``0``)  ` `    ``{ ` `        ``p = (X * p) % Mod; ` `    ``} ` ` `  `    ``return` `p; ` `} ` ` `  `// Function to return the ` `// inverse of factorial of N ` `static` `int` `Inversefactorial(``int` `N) ` `{ ` ` `  `    ``// Base case ` `    ``if` `(N <= ``0``) ` `        ``return` `1``; ` ` `  `    ``int` `fact = ``1``; ` ` `  `    ``for` `(``int` `i = ``1``; i <= N; i++)  ` `    ``{ ` `        ``fact = (fact * i) % Mod; ` `    ``} ` ` `  `    ``return` `power(fact, Mod - ``2``, Mod); ` `} ` ` `  `// Function to return factorial ` `// of n % Mod ` `static` `int` `factorial(``int` `N) ` `{ ` ` `  `    ``// Base case ` `    ``if` `(N <= ``0``) ` `        ``return` `1``; ` ` `  `    ``int` `fact = ``1``; ` ` `  `    ``for` `(``int` `i = ``1``; i <= N; i++)  ` `    ``{ ` `        ``fact = (fact * i) % Mod; ` `    ``} ` ` `  `    ``return` `fact; ` `} ` ` `  `// Function to return  the value ` `// of n! / (( n- k)! * k!) ` `static` `int` `nck(``int` `N, ``int` `K) ` `{ ` `    ``int` `factN = factorial(N); ` `    ``int` `inv = Inversefactorial(K); ` `    ``int` `invFact = Inversefactorial(N - K); ` `    ``return` `(((factN * inv) % Mod) * invFact) % Mod; ` `} ` ` `  `// Function to return the count of ` `// ways to reach (n, m) from (0, 0) ` `static` `int` `TotalWaYs(``int` `N, ``int` `M) ` `{ ` ` `  `    ``// If (N + M) % 3 != 0 ` `    ``if` `(((N + M) % ``3` `)!= ``0``) ` ` `  `        ``// No possible way exists ` `        ``return` `0``; ` ` `  `    ``// Calculate X and Y from the ` `    ``// equations X + 2Y = N ` `    ``// and 2X + Y == M ` `    ``int` `X = N - (N + M) / ``3``; ` `    ``int` `Y = M - (N + M) / ``3``; ` ` `  `    ``if` `(X < ``0` `|| Y < ``0``) ` `        ``return` `0``; ` ` `  `    ``return` `nck(X + Y, Y); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``3``, M = ``3``; ` ` `  `    ``System.out.print(TotalWaYs(N, M)); ` `} ` `} ` ` `  `// This code is contributed by Rohit_ranjan`

## Python3

 `# Python3 program to implement ` `# above approach ` `Mod ``=` `int``(``1e9` `+` `7``) ` ` `  `# Function to return X^Y % Mod ` `def` `power(X, Y, Mod): ` `     `  `    ``# Base case ` `    ``if` `Y ``=``=` `0``: ` `        ``return` `1` `         `  `    ``p ``=` `power(X, Y ``/``/` `2``, Mod) ``%` `Mod ` `    ``p ``=` `(p ``*` `p) ``%` `Mod ` `     `  `    ``if` `Y & ``1``: ` `        ``p ``=` `(X ``*` `p) ``%` `Mod ` `         `  `    ``return` `p ` ` `  `# Function to return the  ` `# inverse of factorial of N  ` `def` `Inversefactorial(N): ` `     `  `    ``# Base case ` `    ``if` `N <``=` `0``: ` `        ``return` `1` `     `  `    ``fact ``=` `1` `    ``for` `i ``in` `range``(``1``, N ``+` `1``): ` `        ``fact ``=` `(fact ``*` `i) ``%` `Mod ` `         `  `    ``return` `power(fact, Mod ``-` `2``, Mod) ` ` `  `# Function to return factorial  ` `# of n % Mod  ` `def` `factorial(N): ` `     `  `    ``# Base case ` `    ``if` `N <``=` `0``: ` `        ``return` `1` `     `  `    ``fact ``=` `1` `    ``for` `i ``in` `range``(``1``, N ``+` `1``): ` `        ``fact ``=` `(fact ``*` `i) ``%` `Mod ` `     `  `    ``return` `fact ` ` `  `# Function to return the value  ` `# of n! / (( n- k)! * k!)  ` `def` `nck(N, K): ` `     `  `    ``factN ``=` `factorial(N) ` `    ``inv ``=` `Inversefactorial(K) ` `    ``invFact ``=` `Inversefactorial(N ``-` `K) ` `     `  `    ``return` `(((factN ``*` `inv) ``%` `Mod) ``*` `invFact) ``%` `Mod ` ` `  `# Function to return the count of  ` `# ways to reach (n, m) from (0, 0)  ` `def` `TotalWays(N, M): ` `     `  `    ``# If (N + M) % 3 != 0  ` `    ``if` `(N ``+` `M) ``%` `3` `!``=` `0``: ` `         `  `        ``# No possible way exists  ` `        ``return` `0` `     `  `    ``# Calculate X and Y from the  ` `    ``# equations X + 2Y = N  ` `    ``# and 2X + Y == M  ` `    ``X ``=` `N ``-` `(N ``+` `M) ``/``/` `3` `    ``Y ``=` `M ``-` `(N ``+` `M) ``/``/` `3` `     `  `    ``if` `X < ``0` `or` `Y < ``0``: ` `        ``return` `0` `         `  `    ``return` `nck(X ``+` `Y, Y) ` ` `  `# Driver code ` `N, M ``=` `3``, ``3` ` `  `print``(TotalWays(N, M)) ` ` `  `# This code is contributed by Stuti Pathak `

## C#

 `// C# program to implement ` `// the above approach ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `static` `int` `Mod = (``int``)(1e9 + 7); ` ` `  `// Function to return X^Y % Mod ` `static` `int` `power(``int` `X, ``int` `Y, ``int` `Mod) ` `{ ` ` `  `    ``// Base Case ` `    ``if` `(Y == 0) ` `        ``return` `1; ` ` `  `    ``int` `p = power(X, Y / 2, Mod) % Mod; ` `    ``p = (p * p) % Mod; ` ` `  `    ``if` `((Y & 1) != 0)  ` `    ``{ ` `        ``p = (X * p) % Mod; ` `    ``} ` `    ``return` `p; ` `} ` ` `  `// Function to return the ` `// inverse of factorial of N ` `static` `int` `Inversefactorial(``int` `N) ` `{ ` ` `  `    ``// Base case ` `    ``if` `(N <= 0) ` `        ``return` `1; ` ` `  `    ``int` `fact = 1; ` ` `  `    ``for``(``int` `i = 1; i <= N; i++)  ` `    ``{ ` `        ``fact = (fact * i) % Mod; ` `    ``} ` `    ``return` `power(fact, Mod - 2, Mod); ` `} ` ` `  `// Function to return factorial ` `// of n % Mod ` `static` `int` `factorial(``int` `N) ` `{ ` ` `  `    ``// Base case ` `    ``if` `(N <= 0) ` `        ``return` `1; ` ` `  `    ``int` `fact = 1; ` ` `  `    ``for``(``int` `i = 1; i <= N; i++)  ` `    ``{ ` `        ``fact = (fact * i) % Mod; ` `    ``} ` `    ``return` `fact; ` `} ` ` `  `// Function to return the value ` `// of n! / (( n- k)! * k!) ` `static` `int` `nck(``int` `N, ``int` `K) ` `{ ` `    ``int` `factN = factorial(N); ` `    ``int` `inv = Inversefactorial(K); ` `    ``int` `invFact = Inversefactorial(N - K); ` `    ``return` `(((factN * inv) % Mod) * invFact) % Mod; ` `} ` ` `  `// Function to return the count of ` `// ways to reach (n, m) from (0, 0) ` `static` `int` `TotalWaYs(``int` `N, ``int` `M) ` `{ ` ` `  `    ``// If (N + M) % 3 != 0 ` `    ``if` `(((N + M) % 3 ) != 0) ` ` `  `        ``// No possible way exists ` `        ``return` `0; ` ` `  `    ``// Calculate X and Y from the ` `    ``// equations X + 2Y = N ` `    ``// and 2X + Y == M ` `    ``int` `X = N - (N + M) / 3; ` `    ``int` `Y = M - (N + M) / 3; ` ` `  `    ``if` `(X < 0 || Y < 0) ` `        ``return` `0; ` ` `  `    ``return` `nck(X + Y, Y); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `N = 3, M = 3; ` ` `  `    ``Console.Write(TotalWaYs(N, M)); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar  `

Output:

```2
```

Time Complexity: O(X + Y + log(mod)).
Auxiliary Space: O(1)

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.