 Open in App
Not now

# Count paths whose sum is not divisible by K in given Matrix

• Difficulty Level : Expert
• Last Updated : 21 Feb, 2023

Given an integer matrix mat[][] of size M x N and an integer K, the task is to return the number of paths from top-left to bottom-right by moving only right and downwards such that the sum of the elements on the path is not divisible by K.

Examples:

Input: mat = [[5, 2, 4], [3, 0, 5], [0, 7, 2]], K = 3
Output: 4

Input: mat = [, ], K = 7
Output: 0

Approach: The problem can be solved using recursion based on the following idea:

Step 1:

• When we have reached the destination, check if the sum is not divisible by K, then we return 1.
• When we have crossed the boundary of the matrix and we couldn’t find the right path, hence we return 0.

Step 2: Try out all possible choices at a given index:

• At every index we have two choices, one to go down and the other to go right. To go down, increase i by 1, and to move towards the right increase j by 1.

Step 3: Count all ways:

•   As we have to count all the possible unique paths, return the sum of all the choices (down and right) from each recursion.

Follow the steps mentioned below to implement the idea:

• Create a recursive function.
• For each call, there are two choices for the element as mentioned above.
• Calculate the value of all possible cases as mentioned above.
• The sum of all choices is the required answer.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Function for calculating paths` `int` `solve(``int` `i, ``int` `j, ``int` `local_sum,` `          ``vector >& grid, ``int` `k, ``int` `m, ``int` `n)` `{` `    ``// Base case` `    ``if` `(i > m - 1 || j > n - 1)` `        ``return` `0;` `    ``if` `(i == m - 1 && j == n - 1) {` `        ``if` `((local_sum + grid[i][j]) % k != 0)` `            ``return` `1;` `        ``else` `            ``return` `0;` `    ``}`   `    ``// Choices of exploring paths` `    ``int` `right = solve(i, j + 1, (local_sum + grid[i][j]),` `                      ``grid, k, m, n);` `    ``int` `down = solve(i + 1, j, (local_sum + grid[i][j]),` `                     ``grid, k, m, n);`   `    ``// Returning the sum of the choices` `    ``return` `(right + down);` `}`   `// Driver code` `int` `main()` `{` `    ``vector > mat` `        ``= { { 5, 2, 4 }, { 3, 0, 5 }, { 0, 7, 2 } };` `    ``int` `K = 3;`   `    ``int` `M = mat.size();` `    ``int` `N = mat.size();`   `    ``// Function call` `    ``int` `ways = solve(0, 0, 0, mat, K, M, N);` `    ``cout << ways << endl;` `    ``return` `0;` `}`

## Java

 `// java code to implement the approach` `import` `java.util.Scanner; ` `import` `java.io.*;`   `class` `GFG` `{` `  `  `// Function for calculating paths` `public` `static` `int` `solve(``int` `i, ``int` `j, ``int` `local_sum,` `         ``int``[][] grid, ``int` `k, ``int` `m, ``int` `n)` `{` `    ``// Base case` `    ``if` `(i > m - ``1` `|| j > n - ``1``)` `        ``return` `0``;` `    ``if` `(i == m - ``1` `&& j == n - ``1``) {` `        ``if` `((local_sum + grid[i][j]) % k != ``0``)` `            ``return` `1``;` `        ``else` `            ``return` `0``;` `    ``}`   `    ``// Choices of exploring paths` `    ``int` `right = solve(i, j + ``1``, (local_sum + grid[i][j]),` `                      ``grid, k, m, n);` `    ``int` `down = solve(i + ``1``, j, (local_sum + grid[i][j]),` `                     ``grid, k, m, n);`   `    ``// Returning the sum of the choices` `    ``return` `(right + down);` `}`   `// Driver code` ` ``public` `static` `void` `main(String[] args)` ` ``{` `   `  `       ``// System.out.println("Hello, World!");` `    ``int` `[][]mat` `        ``= { { ``5``, ``2``, ``4` `}, { ``3``, ``0``, ``5` `}, { ``0``, ``7``, ``2` `} };` `    ``int` `K = ``3``;`   `    ``int` `M = mat.length;` `    ``int` `N = mat[``0``].length;`   `    ``// Function call` `    ``int` `ways = solve(``0``, ``0``, ``0``, mat, K, M, N);` `    ``System.out.println(ways);` `     ``}` `}`   `// this code is contributed by ksam24000`

## Python3

 `# Python code to implement the approach`   `# Function for calculating paths` `def` `solve(i, j, local_sum, grid, k, m, n):`   `    ``# Base case` `    ``if` `(i > m ``-` `1` `or` `j > n ``-` `1``):` `        ``return` `0` `    ``if` `(i ``=``=` `m ``-` `1` `and` `j ``=``=` `n ``-` `1``):` `        ``if` `((local_sum ``+` `grid[i][j]) ``%` `k !``=` `0``):` `            ``return` `1` `        ``else``:` `            ``return` `0`   `    ``# Choices of exploring paths` `    ``right ``=` `solve(i, j ``+` `1``, (local_sum ``+` `grid[i][j]),` `                  ``grid, k, m, n)` `    ``down ``=` `solve(i ``+` `1``, j, (local_sum ``+` `grid[i][j]),` `                 ``grid, k, m, n)`   `    ``# Returning the sum of the choices` `    ``return` `(right ``+` `down)`   `# Driver code` `mat ``=` `[[``5``, ``2``, ``4``], [``3``, ``0``, ``5``], [``0``, ``7``, ``2``]]` `K ``=` `3`   `M ``=` `len``(mat)` `N ``=` `len``(mat[``0``])`   `# Function call` `ways ``=` `solve(``0``, ``0``, ``0``, mat, K, M, N)` `print``(ways)`   `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# code to implement the above approach` `using` `System;` `public` `class` `GFG` `{`   `  ``// Function for calculating paths` `  ``public` `static` `int` `solve(``int` `i, ``int` `j, ``int` `local_sum,` `                          ``int``[,] grid, ``int` `k, ``int` `m, ``int` `n)` `  ``{`   `    ``// Base case` `    ``if` `(i > m - 1 || j > n - 1)` `      ``return` `0;` `    ``if` `(i == m - 1 && j == n - 1) {` `      ``if` `((local_sum + grid[i,j]) % k != 0)` `        ``return` `1;` `      ``else` `        ``return` `0;` `    ``}`   `    ``// Choices of exploring paths` `    ``int` `right = solve(i, j + 1, (local_sum + grid[i,j]),` `                      ``grid, k, m, n);` `    ``int` `down = solve(i + 1, j, (local_sum + grid[i,j]),` `                     ``grid, k, m, n);`   `    ``// Returning the sum of the choices` `    ``return` `(right + down);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{`   `    ``// System.out.println("Hello, World!");` `    ``int` `[,] mat = { { 5, 2, 4 }, { 3, 0, 5 }, { 0, 7, 2 } };` `    ``int` `K = 3;`   `    ``int` `M = mat.GetLength(0);` `    ``int` `N = mat.GetLength(1);`   `    ``// Function call` `    ``int` `ways = solve(0, 0, 0, mat, K, M, N);` `    ``Console.WriteLine(ways);` `  ``}` `}`   `// This code is contributed by AnkThon`

## Javascript

 ``

Output

`4`

Time Complexity: O((M+N-2)C(M-1)) as there can be this many paths
Auxiliary Space: O(N + M) recursion stack space as the path length is (M-1) + (N-1)

Efficient Approach (Using Memoization):

We can use Dynamic Programming to store the answer for overlapping subproblems. We can store the result for the current index i and j and the sum in the DP matrix.

The states of DP can be represented as follows:

• DP[i][j][local_sum]

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach`   `#include ` `using` `namespace` `std;`   `// Function for calculating paths` `int` `solve(``int` `i, ``int` `j, ``int` `local_sum,` `          ``vector >& grid, ``int` `k, ``int` `m, ``int` `n, vector>> &dp)` `{` `    ``// Base case` `    ``if` `(i > m - 1 || j > n - 1)` `        ``return` `0;` `    ``if` `(i == m - 1 && j == n - 1) {` `        ``if` `((local_sum + grid[i][j]) % k != 0)` `            ``return` `1;` `        ``else` `            ``return` `0;` `    ``}` `    `  `    ``// If answer already stored return that` `    ``if``(dp[i][j][local_sum] != -1) ``return` `dp[i][j][local_sum];`   `    ``// Choices of exploring paths` `    ``int` `right = solve(i, j + 1, (local_sum + grid[i][j]) % k,` `                      ``grid, k, m, n, dp);` `    ``int` `down = solve(i + 1, j, (local_sum + grid[i][j]) % k,` `                     ``grid, k, m, n, dp);`   `    ``// Returning the sum of the choices` `    ``return` `dp[i][j][local_sum] = (right + down);` `}`   `// Driver code` `int` `main()` `{` `    ``vector > mat` `        ``= { { 5, 2, 4 }, { 3, 0, 5 }, { 0, 7, 2 } };` `    ``int` `K = 3;`   `    ``int` `M = mat.size();` `    ``int` `N = mat.size();` `    `  `     ``// 3d dp vector` `    ``vector>> dp(M, vector>(N, vector<``int``>(K,-1)));`   `    ``// Function call` `    ``int` `ways = solve(0, 0, 0, mat, K, M, N, dp);` `    ``cout << ways << endl;` `    ``return` `0;` `}`

## Java

 `// Java code to implement the approach` `import` `java.util.*;`   `public` `class` `GFG {`   `  ``// Function for calculating paths` `  ``static` `int` `solve(``int` `i, ``int` `j, ``int` `local_sum,` `                   ``int``[][] grid, ``int` `k, ``int` `m, ``int` `n,` `                   ``int``[][][] dp)` `  ``{` `    `  `    ``// Base case` `    ``if` `(i > m - ``1` `|| j > n - ``1``)` `      ``return` `0``;` `    ``if` `(i == m - ``1` `&& j == n - ``1``) {` `      ``if` `((local_sum + grid[i][j]) % k != ``0``)` `        ``return` `1``;` `      ``else` `        ``return` `0``;` `    ``}`   `    ``// If answer already stored return that` `    ``if` `(dp[i][j][local_sum] != -``1``)` `      ``return` `dp[i][j][local_sum];`   `    ``// Choices of exploring paths` `    ``int` `right` `      ``= solve(i, j + ``1``, (local_sum + grid[i][j]) % k,` `              ``grid, k, m, n, dp);` `    ``int` `down` `      ``= solve(i + ``1``, j, (local_sum + grid[i][j]) % k,` `              ``grid, k, m, n, dp);`   `    ``// Returning the sum of the choices` `    ``return` `dp[i][j][local_sum] = (right + down);` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int``[][] mat` `      ``= { { ``5``, ``2``, ``4` `}, { ``3``, ``0``, ``5` `}, { ``0``, ``7``, ``2` `} };` `    ``int` `K = ``3``;`   `    ``int` `M = mat.length;` `    ``int` `N = mat[``0``].length;`   `    ``// 3d dp vector` `    ``int``[][][] dp` `      ``= ``new` `int``[M][N][K]; ``//(M, vector>(N,` `    ``// vector(K,-1)));` `    ``for` `(``int` `i = ``0``; i < M; i++) {` `      ``for` `(``int` `j = ``0``; j < N; j++) {` `        ``for` `(``int` `k = ``0``; k < K; k++) {` `          ``dp[i][j][k] = -``1``;` `        ``}` `      ``}` `    ``}`   `    ``// Function call` `    ``int` `ways = solve(``0``, ``0``, ``0``, mat, K, M, N, dp);` `    ``System.out.println(ways);` `  ``}` `}`   `// This code is contributed by Karandeep1234`

## Python3

 `def` `solve(i, j, local_sum, grid, k, m, n, dp):` `    ``# Base case` `    ``if` `i > m ``-` `1` `or` `j > n ``-` `1``:` `        ``return` `0` `    ``if` `i ``=``=` `m ``-` `1` `and` `j ``=``=` `n ``-` `1``:` `        ``if` `(local_sum ``+` `grid[i][j]) ``%` `k !``=` `0``:` `            ``return` `1` `        ``else``:` `            ``return` `0` `    ``# If answer already stored return that` `    ``if` `dp[i][j][local_sum] !``=` `-``1``:` `        ``return` `dp[i][j][local_sum]`   `    ``# Choices of exploring paths` `    ``right ``=` `solve(i, j ``+` `1``, (local_sum ``+` `grid[i][j]) ``%` `k, grid, k, m, n, dp)` `    ``down ``=` `solve(i ``+` `1``, j, (local_sum ``+` `grid[i][j]) ``%` `k, grid, k, m, n, dp)`   `    ``# Returning the sum of the choices` `    ``dp[i][j][local_sum] ``=` `(right ``+` `down)` `    ``return` `dp[i][j][local_sum]`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``mat ``=` `[[``5``, ``2``, ``4``], [``3``, ``0``, ``5``], [``0``, ``7``, ``2``]]` `    ``K ``=` `3` `    ``M ``=` `len``(mat)` `    ``N ``=` `len``(mat[``0``])`   `    ``# 3d dp list` `    ``dp ``=` `[[[``-``1` `for` `k ``in` `range``(K)] ``for` `j ``in` `range``(N)] ``for` `i ``in` `range``(M)]`   `    ``# Function call` `    ``ways ``=` `solve(``0``, ``0``, ``0``, mat, K, M, N, dp)` `    ``print``(ways)`   `# This code is contributed by Vikram_Shirsat`

## C#

 `using` `System;`   `class` `GFG {` `  ``// Function for calculating paths` `  ``static` `int` `Solve(``int` `i, ``int` `j, ``int` `localSum,` `                   ``int``[,] grid, ``int` `k, ``int` `m, ``int` `n,` `                   ``int``[,,] dp)` `  ``{` `    ``// Base case` `    ``if` `(i > m - 1 || j > n - 1)` `      ``return` `0;` `    ``if` `(i == m - 1 && j == n - 1) {` `      ``if` `((localSum + grid[i, j]) % k != 0)` `        ``return` `1;` `      ``else` `        ``return` `0;` `    ``}`   `    ``// If answer already stored return that` `    ``if` `(dp[i, j, localSum] != -1)` `      ``return` `dp[i, j, localSum];`   `    ``// Choices of exploring paths` `    ``int` `right` `      ``= Solve(i, j + 1, (localSum + grid[i, j]) % k,` `              ``grid, k, m, n, dp);` `    ``int` `down` `      ``= Solve(i + 1, j, (localSum + grid[i, j]) % k,` `              ``grid, k, m, n, dp);`   `    ``// Returning the sum of the choices` `    ``return` `dp[i, j, localSum] = (right + down);` `  ``}`   `  ``// Driver code` `  ``static` `void` `Main(``string``[] args)` `  ``{` `    ``int``[,] mat` `      ``= {{5, 2, 4}, {3, 0, 5}, {0, 7, 2}};` `    ``int` `K = 3;`   `    ``int` `M = mat.GetLength(0);` `    ``int` `N = mat.GetLength(1);`   `    ``// 3d dp array` `    ``int``[,,] dp` `      ``= ``new` `int``[M, N, K];` `    ``for` `(``int` `i = 0; i < M; i++) {` `      ``for` `(``int` `j = 0; j < N; j++) {` `        ``for` `(``int` `k = 0; k < K; k++) {` `          ``dp[i, j, k] = -1;` `        ``}` `      ``}` `    ``}`   `    ``// Function call` `    ``int` `ways = Solve(0, 0, 0, mat, K, M, N, dp);` `    ``Console.WriteLine(ways);` `  ``}` `}`

## Javascript

 `// Javascript code to implement the approach` `function` `solve(i, j, local_sum, grid, k, m, n, dp){` `// Base case` `if` `(i > m - 1 || j > n - 1){` `return` `0;` `}` `if` `(i == m - 1 && j == n - 1){` `if` `((local_sum + grid[i][j]) % k !== 0){` `return` `1;` `}` `else``{` `return` `0;` `}` `}` `// If answer already stored return that` `if` `(dp[i][j][local_sum] !== -1){` `return` `dp[i][j][local_sum];` `}` `// Choices of exploring paths` `let right = solve(i, j + 1, (local_sum + grid[i][j]) % k, grid, k, m, n, dp);` `let down = solve(i + 1, j, (local_sum + grid[i][j]) % k, grid, k, m, n, dp);`   `// Returning the sum of the choices` `dp[i][j][local_sum] = (right + down);` `return` `dp[i][j][local_sum];` `}`   `// Driver code` `let mat = [[5, 2, 4], [3, 0, 5], [0, 7, 2]];` `let K = 3;` `let M = mat.length;` `let N = mat.length;`   `// 3d dp list` `let dp = ``new` `Array(M);` `for``(let i=0;i

Output

`4`

Time Complexity: O(m*n*k), where len is the length of the array
Auxiliary Space: O(m*n*k)

My Personal Notes arrow_drop_up
Related Articles