 Open in App
Not now

# Number of paths with exactly k coins

• Difficulty Level : Hard
• Last Updated : 28 Aug, 2022

Given a matrix where every cell has some number of coins. Count number of ways to reach bottom right from top left with exactly k coins. We can move to (i+1, j) and (i, j+1) from a cell (i, j).

Example:

```Input:  k = 12
mat[][] = { {1, 2, 3},
{4, 6, 5},
{3, 2, 1}
};
Output:  2
There are two paths with 12 coins
1 -> 2 -> 6 -> 2 -> 1
1 -> 2 -> 3 -> 5 -> 1```

## We strongly recommend that you click here and practice it, before moving on to the solution.

The above problem can be recursively defined as below:

```pathCount(m, n, k):   Number of paths to reach mat[m][n] from mat
with exactly k coins

If (m == 0 and n == 0)
return 1 if mat == k else return 0
Else:
pathCount(m, n, k) = pathCount(m-1, n, k - mat[m][n]) +
pathCount(m, n-1, k - mat[m][n]) ```

Below is the implementation of above recursive algorithm.

## C++14

 `  `    `// A Naive Recursive C++ program ` `// to count paths with exactly` `// 'k' coins` `#include ` `#define R 3` `#define C 3` `using` `namespace` `std;`   `// Recursive function to count paths with sum k from` `// (0, 0) to (m, n)` `int` `pathCountRec(``int` `mat[][C], ``int` `m, ``int` `n, ``int` `k)` `{` `    ``// Base cases` `    ``if` `(m < 0 || n < 0 || k < 0) ``return` `0;` `    ``if` `(m==0 && n==0) ``return` `(k == mat[m][n]);`   `    ``// (m, n) can be reached either through (m-1, n) or` `    ``// through (m, n-1)` `    ``return` `pathCountRec(mat, m-1, n, k-mat[m][n]) +` `           ``pathCountRec(mat, m, n-1, k-mat[m][n]);` `}`   `// A wrapper over pathCountRec()` `int` `pathCount(``int` `mat[][C], ``int` `k)` `{` `    ``return` `pathCountRec(mat, R-1, C-1, k);` `}`   `// Driver program` `int` `main()` `{` `    ``int` `k = 12;` `    ``int` `mat[R][C] = { {1, 2, 3},` `                      ``{4, 6, 5},` `                      ``{3, 2, 1}` `                  ``};` `    ``cout << pathCount(mat, k);` `    ``return` `0;` `}`

## Java

 `// A Naive Recursive Java program to ` `// count paths with exactly 'k' coins  `   `class` `GFG {`   `    ``static` `final` `int` `R = ``3``;` `    ``static` `final` `int` `C = ``3``;`   `// Recursive function to count paths with sum k from ` `// (0, 0) to (m, n) ` `    ``static` `int` `pathCountRec(``int` `mat[][], ``int` `m, ``int` `n, ``int` `k) {` `        ``// Base cases ` `        ``if` `(m < ``0` `|| n < ``0` `|| k < ``0``) {` `            ``return` `0``;` `        ``}` `        ``if` `(m == ``0` `&& n == ``0` `&& (k == mat[m][n])) {` `            ``return` `1``;` `        ``}`   `        ``// (m, n) can be reached either through (m-1, n) or ` `        ``// through (m, n-1) ` `        ``return` `pathCountRec(mat, m - ``1``, n, k - mat[m][n])` `                ``+ pathCountRec(mat, m, n - ``1``, k - mat[m][n]);` `    ``}`   `// A wrapper over pathCountRec() ` `    ``static` `int` `pathCount(``int` `mat[][], ``int` `k) {` `        ``return` `pathCountRec(mat, R - ``1``, C - ``1``, k);` `    ``}`   `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) {` `        ``int` `k = ``12``;` `        ``int` `mat[][] = {{``1``, ``2``, ``3``},` `        ``{``4``, ``6``, ``5``},` `        ``{``3``, ``2``, ``1``}` `        ``};` `        ``System.out.println(pathCount(mat, k));` `    ``}` `}`   `/* This Java code is contributed by Rajput-Ji*/`

## Python3

 `# A Naive Recursive Python program to` `# count paths with exactly 'k' coins`   `R ``=` `3` `C ``=` `3`   `# Recursive function to count paths` `# with sum k from (0, 0) to (m, n)` `def` `pathCountRec(mat, m, n, k):`   `    ``# Base cases` `    ``if` `m < ``0` `or` `n < ``0` `or` `k < ``0``:` `        ``return` `0` `    ``elif` `m ``=``=` `0` `and` `n ``=``=` `0``:` `        ``return` `k ``=``=` `mat[m][n]`   `    ``# #(m, n) can be reached either` `    ``# through (m-1, n) or through` `    ``# (m, n-1)` `    ``return` `(pathCountRec(mat, m``-``1``, n, k``-``mat[m][n]) ` `         ``+` `pathCountRec(mat, m, n``-``1``, k``-``mat[m][n]))`   `# A wrapper over pathCountRec()` `def` `pathCount(mat, k):` `    ``return` `pathCountRec(mat, R``-``1``, C``-``1``, k)`   `# Driver Program` `k ``=` `12` `mat ``=` `[[``1``, ``2``, ``3``],` `       ``[``4``, ``6``, ``5``],` `       ``[``3``, ``2``, ``1``]]`   `print``(pathCount(mat, k))`   `# This code is contributed by Shrikant13.`

## C#

 `using` `System;`   `// A Naive Recursive c# program to ` `// count paths with exactly 'k' coins `   `public` `class` `GFG` `{`   `    ``public` `const` `int` `R = 3;` `    ``public` `const` `int` `C = 3;`   `// Recursive function to count paths with sum k from ` `// (0, 0) to (m, n) ` `    ``public` `static` `int` `pathCountRec(``int``[][] mat, ``int` `m, ``int` `n, ``int` `k)` `    ``{` `        ``// Base cases ` `        ``if` `(m < 0 || n < 0 || k < 0)` `        ``{` `            ``return` `0;` `        ``}` `        ``if` `(m == 0 && n == 0 && (k == mat[m][n]))` `        ``{` `            ``return` `1;` `        ``}`   `        ``// (m, n) can be reached either through (m-1, n) or ` `        ``// through (m, n-1) ` `        ``return` `pathCountRec(mat, m - 1, n, k - mat[m][n]) ` `                ``+ pathCountRec(mat, m, n - 1, k - mat[m][n]);` `    ``}`   `// A wrapper over pathCountRec() ` `    ``public` `static` `int` `pathCount(``int``[][] mat, ``int` `k)` `    ``{` `        ``return` `pathCountRec(mat, R - 1, C - 1, k);` `    ``}`   `    ``// Driver code ` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `k = 12;` `        ``int``[][] mat = ``new` `int``[][]` `        ``{` `            ``new` `int``[] {1, 2, 3},` `            ``new` `int``[] {4, 6, 5},` `            ``new` `int``[] {3, 2, 1}` `        ``};` `        ``Console.WriteLine(pathCount(mat, k));` `    ``}` `}`   `// This code is contributed by Shrikant13`

## PHP

 ``

## Javascript

 ``

Output

`2`

Time Complexity: O(2m+n)
Auxiliary Space: O(m*n), since m*n extra space has been taken.

The time complexity of above solution recursive is exponential. We can solve this problem in Pseudo Polynomial Time (time complexity is dependent on numeric value of input) using Dynamic Programming. The idea is to use a 3 dimensional table dp[m][n][k] where m is row number, n is column number and k is number of coins. Below is Dynamic Programming based the implementation.

## C++14

 `// A Dynamic Programming based C++ program to count paths with` `// exactly 'k' coins` `#include ` `#define R 3` `#define C 3` `#define MAX_K 1000` `using` `namespace` `std;`   `int` `dp[R][C][MAX_K];`   `int` `pathCountDPRecDP(``int` `mat[][C], ``int` `m, ``int` `n, ``int` `k)` `{` `    ``// Base cases` `    ``if` `(m < 0 || n < 0 || k < 0) ``return` `0;` `    ``if` `(m==0 && n==0) ``return` `(k == mat[m][n]);`   `    ``// If this subproblem is already solved` `    ``if` `(dp[m][n][k] != -1) ``return` `dp[m][n][k];`   `    ``// (m, n) can be reached either through (m-1, n) or` `    ``// through (m, n-1)` `    ``dp[m][n][k] = pathCountDPRecDP(mat, m-1, n, k-mat[m][n]) +` `                  ``pathCountDPRecDP(mat, m, n-1, k-mat[m][n]);`   `    ``return` `dp[m][n][k];` `}`   `// This function mainly initializes dp[][][] and calls` `// pathCountDPRecDP()` `int` `pathCountDP(``int` `mat[][C], ``int` `k)` `{` `    ``memset``(dp, -1, ``sizeof` `dp);` `    ``return` `pathCountDPRecDP(mat, R-1, C-1, k);` `}`   `// Driver Program to test above functions` `int` `main()` `{` `    ``int` `k = 12;` `    ``int` `mat[R][C] = { {1, 2, 3},` `                      ``{4, 6, 5},` `                      ``{3, 2, 1}` `                  ``};` `    ``cout << pathCountDP(mat, k);` `    ``return` `0;` `}`

## Java

 `// A Dynamic Programming based JAVA program to count paths` `// with exactly 'k' coins`   `class` `GFG {`   `    ``static` `final` `int` `R = ``3``;` `    ``static` `final` `int` `C = ``3``;` `    ``static` `final` `int` `MAX_K = ``100``;`   `    ``static` `int``[][][] dp = ``new` `int``[R][C][MAX_K];`   `    ``static` `int` `pathCountDPRecDP(``int``[][] mat, ``int` `m, ``int` `n,` `                                ``int` `k)` `    ``{` `        ``// Base cases` `        ``if` `(m < ``0` `|| n < ``0` `|| k < ``0``)` `            ``return` `0``;` `        ``if` `(m == ``0` `&& n == ``0``)` `            ``return` `(k == mat[m][n] ? ``1` `: ``0``);`   `        ``// If this subproblem is already solved` `        ``if` `(dp[m][n][k] != -``1``)` `            ``return` `dp[m][n][k];`   `        ``// (m, n) can be reached either through (m-1, n) or` `        ``// through (m, n-1)` `        ``dp[m][n][k]` `            ``= pathCountDPRecDP(mat, m - ``1``, n, k - mat[m][n])` `              ``+ pathCountDPRecDP(mat, m, n - ``1``,` `                                 ``k - mat[m][n]);`   `        ``return` `dp[m][n][k];` `    ``}`   `    ``// This function mainly initializes dp[][][] and calls` `    ``// pathCountDPRecDP()` `    ``static` `int` `pathCountDP(``int``[][] mat, ``int` `k)` `    ``{` `        ``for` `(``int` `i = ``0``; i < R; i++)` `            ``for` `(``int` `j = ``0``; j < C; j++)` `                ``for` `(``int` `l = ``0``; l < MAX_K; l++)` `                    ``dp[i][j][l] = -``1``;`   `        ``return` `pathCountDPRecDP(mat, R - ``1``, C - ``1``, k);` `    ``}`   `    ``// Driver Program to test above functions` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `k = ``12``;` `        ``int``[][] mat = ``new` `int``[][] { ``new` `int``[] { ``1``, ``2``, ``3` `},` `                                    ``new` `int``[] { ``4``, ``6``, ``5` `},` `                                    ``new` `int``[] { ``3``, ``2``, ``1` `} };`   `        ``System.out.println(pathCountDP(mat, k));` `    ``}` `}`   `// This code is contributed by ihritik`

## Python3

 `# A Dynamic Programming based Python3 program to` `# count paths with exactly 'k' coins` `R ``=` `3` `C ``=` `3` `MAX_K ``=` `1000`   `def` `pathCountDPRecDP(mat, m, n, k):`   `    ``# Base cases` `    ``if` `m < ``0` `or` `n < ``0` `or` `k < ``0``:` `        ``return` `0` `    ``elif` `m ``=``=` `0` `and` `n ``=``=` `0``:` `        ``return` `k ``=``=` `mat[m][n]` `    `  `    ``# If this subproblem is already solved` `    ``if` `(dp[m][n][k] !``=` `-``1``):` `        ``return` `dp[m][n][k]`   `    ``# #(m, n) can be reached either` `    ``# through (m-1, n) or through` `    ``# (m, n-1)` `    ``dp[m][n][k] ``=` `(pathCountDPRecDP(mat, m ``-` `1``, n, k ``-` `mat[m][n]) ``+` `                   ``pathCountDPRecDP(mat, m, n ``-` `1``, k ``-` `mat[m][n]))` `    `  `    ``return` `dp[m][n][k]`   `# A wrapper over pathCountDPRecDP()` `def` `pathCountDP(mat, k):` `    ``return` `pathCountDPRecDP(mat, R ``-` `1``, C ``-` `1``, k)`   `# Driver Code` `k ``=` `12`   `# Initialising dp[][][]` `dp ``=` `[[ [``-``1` `for` `col ``in` `range``(MAX_K)] ` `            ``for` `col ``in` `range``(C)] ` `            ``for` `row ``in` `range``(R)]`   `mat ``=` `[[``1``, ``2``, ``3``],` `       ``[``4``, ``6``, ``5``],` `       ``[``3``, ``2``, ``1``]]`   `print``(pathCountDP(mat, k))`   `# This code is contributed by ashutosh450`

## C#

 `// A Dynamic Programming based C# program ` `// to count paths with exactly 'k' coins` `using` `System;`   `class` `GFG` `{` `    ``static` `readonly` `int` `R = 3;` `    ``static` `readonly` `int` `C = 3;` `    ``static` `readonly` `int` `MAX_K = 100;` `    `  `    ``static` `int` `[,,]dp = ``new` `int``[R, C, MAX_K];` `    `  `    ``static` `int` `pathCountDPRecDP(``int` `[,]mat, ``int` `m, ` `                                ``int` `n, ``int` `k)` `    ``{` `        ``// Base cases` `        ``if` `(m < 0 || n < 0 || k < 0) ``return` `0;` `        ``if` `(m == 0 && n == 0) ` `            ``return` `(k == mat[m, n] ? 1 : 0);` `    `  `        ``// If this subproblem is already solved` `        ``if` `(dp[m, n, k] != -1) ``return` `dp[m, n, k];` `    `  `        ``// (m, n) can be reached either through (m-1, n) or` `        ``// through (m, n-1)` `        ``dp[m, n, k] = pathCountDPRecDP(mat, m - 1, n, k - mat[m, n]) +` `                      ``pathCountDPRecDP(mat, m, n - 1, k - mat[m, n]);` `    `  `        ``return` `dp[m, n, k];` `    ``}` `    `  `    ``// This function mainly initializes [,]dp[] and ` `    ``// calls pathCountDPRecDP()` `    ``static` `int` `pathCountDP(``int` `[,]mat, ``int` `k)` `    ``{` `        ``for``(``int` `i = 0; i < R; i++)` `            ``for``(``int` `j = 0; j < C; j++)` `                ``for``(``int` `l = 0; l < MAX_K; l++)` `                ``dp[i, j, l] = -1;` `                    `  `        ``return` `pathCountDPRecDP(mat, R - 1, C - 1, k);` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `Main(String []args)` `    ``{` `        ``int` `k = 12;` `        ``int``[,] mat = { {1, 2, 3},` `                       ``{4, 6, 5},` `                       ``{3, 2, 1}};` `                    `  `        ``Console.WriteLine(pathCountDP(mat, k));` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

`2`

Time complexity of this solution is O(m*n*k).
Auxiliary Space: O(m*n*k)

My Personal Notes arrow_drop_up
Related Articles