Skip to content
Related Articles

Related Articles

Table of Contents

Number of paths with exactly k coins

Improve Article
Save Article
Like Article
  • Difficulty Level : Hard
  • Last Updated : 22 Mar, 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[0][0] 
                      with exactly k coins

If (m == 0 and n == 0)
   return 1 if mat[0][0] == 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 <bits/stdc++.h>
#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



<?php
// A Naive Recursive PHP 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)
function pathCountRec( $mat, $m, $n, $k)
{
     
    // Base cases
    if ($m < 0 or $n < 0 or $k < 0)
        return 0;
    if ($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()
function pathCount($mat, $k)
{
    global $R, $C;
    return pathCountRec($mat, $R-1,
                            $C-1, $k);
}
 
// Driver program
 
    $k = 12;
    $mat = array(array(1, 2, 3),
                 array(4, 6, 5),
                 array(3, 2, 1) );
                  
    echo pathCount($mat, $k);
 
// This code is contributed by anuj_67.
?>
Javascript



<script>
 
// A Naive Recursive Javascript program
// to count paths with exactly
// 'k' coins
let R = 3;
let C = 3;
 
// Recursive function to count paths with
// sum k from (0, 0) to (m, n)
function pathCountRec(mat, m, n, 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()
function pathCount(mat, k)
{
    return pathCountRec(mat, R - 1, C - 1, k);
}
 
// Driver code
let k = 12;
let mat = [ [ 1, 2, 3 ],
            [ 4, 6, 5 ],
            [ 3, 2, 1 ] ];
             
document.write(pathCount(mat, k));
 
// This code is contributed by divyesh072019
 
</script>
Output
2
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 <bits/stdc++.h>
#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



<script>
// A Dynamic Programming based javascript program to count paths with
// exactly 'k' coins
     var R = 3;
     var C = 3;
     var MAX_K = 100;
 
     var dp = Array(R).fill().map(()=>Array(C).fill().map(()=>Array(MAX_K).fill(0)));
 
    function pathCountDPRecDP(mat , m , n , 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()
    function pathCountDP(mat , k) {
        for (i = 0; i < R; i++)
            for (j = 0; j < C; j++)
                for (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
     
        var k = 12;
        var mat = [[ 1, 2, 3 ],[ 4, 6, 5 ], [ 3, 2, 1 ] ];
 
        document.write(pathCountDP(mat, k));
 
 
// This code contributed by aashish1995
</script>
Output
2
Time complexity of this solution is O(m*n*k). 
Thanks to Gaurav Ahirwar for suggesting above solution.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 

My Personal Notes
arrow_drop_up
Previous
Find a common element in all rows of a given row-wise sorted matrix
Next

Collect maximum coins before hitting a dead end
Recommended Articles
Page :
Count number of paths whose weight is exactly X and has at-least one edge of weight M
04, Jan 19
Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths
20, Jun 20
Minimum steps to convert all paths in matrix from top left to bottom right as palindromic paths | Set 2
29, Jul 20
Unique paths covering every non-obstacle block exactly once in a grid
23, Jan 19
Minimum number of coins that can generate all the values in the given range
13, Nov 19
Minimum number of coins to be collected per hour to empty N piles in at most H hours
18, Dec 20
Minimum number of coins needed to remove all the elements of the array based on given rules
10, Sep 21
Find minimum number of coins that make a given value
13, Aug 15
Collect maximum coins before hitting a dead end
03, Nov 15
Probability of getting at least K heads in N tosses of Coins
21, Feb 17
Burst Balloon to maximize coins
02, Oct 18
Probability of getting more heads than tails when N biased coins are tossed
26, Jun 19
Remove Minimum coins such that absolute difference between any two piles is less than K
10, Jul 19
Generate a combination of minimum coins that sums to a given value
15, Sep 20
Maximum money that can be collected by both the players in a game of removal of coins
16, May 21
Maximum amount of money that can be collected by a player in a game of coins
15, Feb 21
Count all unique outcomes possible by performing S flips on N coins
17, Mar 21
Number of palindromic paths in a matrix
30, Dec 16
Maths behind number of paths in matrix problem
28, Feb 19
Total number of decreasing paths in a matrix
14, Jun 18
Number of different cyclic paths of length N in a tetrahedron
02, Aug 18
Number of paths from source to destination in a directed acyclic graph
28, Aug 18
Paths with maximum number of 'a' from (1, 1) to (X, Y) vertically or horizontally
20, Nov 18
Number of Paths of Weight W in a K-ary tree
08, Dec 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!