Given three integers R, B, and W which denote the number of runs, balls, and wickets. One can score 0, 1, 2, 3, 4, 6, or a wicket in a single ball in a cricket match. The task is to count the number of ways in which a team can score exactly R runs in exactly B balls with at-most W wickets. Since the number of ways will be large, print the answer modulo 1000000007. 
Examples: 
 
Input: R = 4, B = 2, W = 2Â
Output: 7Â
The 7 ways are:Â
0, 4Â
4, 0Â
Wicket, 4Â
4, WicketÂ
1, 3Â
3, 1Â
2, 2Â
Input: R = 40, B = 10, W = 4Â
Output: 653263Â
Â
Â
Approach: The problem can be solved using Dynamic Programming and Combinatorics. The recurrence will have 6 states, we initially start with runs = 0, balls = 0 and wickets = 0. The states will be: 
 
- If a team scores 1 run off a ball then runs = runs + 1 and balls = balls + 1.
- If a team scores 2 runs off a ball then runs = runs + 2 and balls = balls + 1.
- If a team scores 3 runs off a ball then runs = runs + 3 and balls = balls + 1.
- If a team scores 4 runs off a ball then runs = runs + 4 and balls = balls + 1.
- If a team scores 6 runs off a ball then runs = runs + 6 and balls = balls + 1.
- If a team scores no run off a ball then runs = runs and balls = balls + 1.
- If a team loses 1 wicket off a ball then runs = runs and balls = balls + 1 and wickets = wickets + 1.
The DP will consist of three stages, with the run state being a maximum of 6 * Balls, since it is the maximum possible. Hence dp[i][j][k] denotes the number of ways in which i runs can be scored in exactly j balls with losing k wickets. 
Below is the implementation of the above approach: 
 
C++
| // C++ implementation of the approach#include <bits/stdc++.h>usingnamespacestd;#define mod 1000000007#define RUNMAX 300#define BALLMAX 50#define WICKETMAX 10  // Function to return the number of ways// to score R runs in B balls with// at most W wicketsintCountWays(intr, intb, intl, intR, intB, intW,              intdp[RUNMAX][BALLMAX][WICKETMAX]){      // If the wickets lost are more    if(l > W)        return0;      // If runs scored are more    if(r > R)        return0;      // If condition is met    if(b == B && r == R)        return1;      // If no run got scored    if(b == B)        return0;      // Already visited state    if(dp[r][b][l] != -1)        returndp[r][b][l];      intans = 0;      // If scored 0 run    ans += CountWays(r, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 1 run    ans += CountWays(r + 1, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 2 runs    ans += CountWays(r + 2, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 3 runs    ans += CountWays(r + 3, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 4 runs    ans += CountWays(r + 4, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 6 runs    ans += CountWays(r + 6, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored no run and lost a wicket    ans += CountWays(r, b + 1, l + 1, R, B, W, dp);    ans = ans % mod;      // Memoize and return    returndp[r][b][l] = ans;}  // Driver codeintmain(){    intR = 40, B = 10, W = 4;      intdp[RUNMAX][BALLMAX][WICKETMAX];    memset(dp, -1, sizeofdp);      cout << CountWays(0, 0, 0, R, B, W, dp);      return0;} | 
Java
| // Java implementation of the approach  classGFG{     Âstaticintmod = 1000000007;staticintRUNMAX = 300;staticintBALLMAX = 50;staticintWICKETMAX = 10; Â// Function to return the number of ways// to score R runs in B balls with// at most W wicketsstaticintCountWays(intr, intb, intl,                    intR, intB, intW,                            int[][][]dp){ Â    // If the wickets lost are more    if(l > W)        return0; Â    // If runs scored are more    if(r > R)        return0; Â    // If condition is met    if(b == B && r == R)        return1; Â    // If no run got scored    if(b == B)        return0; Â    // Already visited state    if(dp[r][b][l] != -1)        returndp[r][b][l]; Â    intans = 0; Â    // If scored 0 run    ans += CountWays(r, b + 1, l, R, B, W, dp);    ans = ans % mod; Â    // If scored 1 run    ans += CountWays(r + 1, b + 1, l, R, B, W, dp);    ans = ans % mod; Â    // If scored 2 runs    ans += CountWays(r + 2, b + 1, l, R, B, W, dp);    ans = ans % mod; Â    // If scored 3 runs    ans += CountWays(r + 3, b + 1, l, R, B, W, dp);    ans = ans % mod; Â    // If scored 4 runs    ans += CountWays(r + 4, b + 1, l, R, B, W, dp);    ans = ans % mod; Â    // If scored 6 runs    ans += CountWays(r + 6, b + 1, l, R, B, W, dp);    ans = ans % mod; Â    // If scored no run and lost a wicket    ans += CountWays(r, b + 1, l + 1, R, B, W, dp);    ans = ans % mod; Â    // Memoize and return    returndp[r][b][l] = ans;} Â// Driver codepublicstaticvoidmain(String[] args){    intR = 40, B = 10, W = 4; Â    int[][][] dp = newint[RUNMAX][BALLMAX][WICKETMAX];    for(inti = 0; i < RUNMAX;i++)        for(intj = 0; j < BALLMAX; j++)            for(intk = 0; k < WICKETMAX; k++)    dp[i][j][k]=-1; Â    System.out.println(CountWays(0, 0, 0, R, B, W, dp));}}  // This code has been contributed by 29AjayKumar | 
Python3
| # Python3 implementation of the approachmod =1000000007RUNMAX =300BALLMAX =50WICKETMAX =10  # Function to return the number of ways# to score R runs in B balls with# at most W wicketsdefCountWays(r, b, l, R, B, W, dp):    Â    # If the wickets lost are more    if(l > W):        return0;      # If runs scored are more    if(r > R):        return0;      # If condition is met    if(b ==B andr ==R):        return1;      # If no run got scored    if(b ==B):        return0;      # Already visited state    if(dp[r][b][l] !=-1):        returndp[r][b][l]        Â    ans =0;      # If scored 0 run    ans +=CountWays(r, b +1, l,                     R, B, W, dp);    ans =ans %mod;      # If scored 1 run    ans +=CountWays(r +1, b +1, l,                      R, B, W, dp);    ans =ans %mod;      # If scored 2 runs    ans +=CountWays(r +2, b +1, l,                     R, B, W, dp);    ans =ans %mod;      # If scored 3 runs    ans +=CountWays(r +3, b +1, l,                     R, B, W, dp);    ans =ans %mod;      # If scored 4 runs    ans +=CountWays(r +4, b +1, l,                      R, B, W, dp);    ans =ans %mod;      # If scored 6 runs    ans +=CountWays(r +6, b +1, l,                     R, B, W, dp);    ans =ans %mod;      # If scored no run and lost a wicket    ans +=CountWays(r, b +1, l +1,                      R, B, W, dp);    ans =ans %mod;    Â    # Memoize and return    dp[r][b][l] =ans    Â    returnans;    Â# Driver code    if__name__=="__main__":    Â    R =40    B =10    W =40    Â    dp =[[[-1fork inrange(WICKETMAX)]                forj inrange(BALLMAX)]                fori inrange(RUNMAX)]    Â    print(CountWays(0, 0, 0, R, B, W, dp))  # This code is contributed by rutvik_56 | 
C#
| // C# implementation of the approachusingSystem;usingSystem.Collections.Generic;usingSystem.Linq;  classGFG{    Âstaticintmod = 1000000007;staticintRUNMAX = 300;staticintBALLMAX = 50;staticintWICKETMAX = 10;  // Function to return the number of ways// to score R runs in B balls with// at most W wicketsstaticintCountWays(intr, intb, intl,                    intR, intB, intW,                            int[,,]dp){      // If the wickets lost are more    if(l > W)        return0;      // If runs scored are more    if(r > R)        return0;      // If condition is met    if(b == B && r == R)        return1;      // If no run got scored    if(b == B)        return0;      // Already visited state    if(dp[r, b, l] != -1)        returndp[r, b, l];      intans = 0;      // If scored 0 run    ans += CountWays(r, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 1 run    ans += CountWays(r + 1, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 2 runs    ans += CountWays(r + 2, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 3 runs    ans += CountWays(r + 3, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 4 runs    ans += CountWays(r + 4, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored 6 runs    ans += CountWays(r + 6, b + 1, l, R, B, W, dp);    ans = ans % mod;      // If scored no run and lost a wicket    ans += CountWays(r, b + 1, l + 1, R, B, W, dp);    ans = ans % mod;      // Memoize and return    returndp[r, b, l] = ans;}  // Driver codestaticvoidMain(){    intR = 40, B = 10, W = 4;      int[,,] dp = newint[RUNMAX, BALLMAX, WICKETMAX];    for(inti = 0; i < RUNMAX;i++)        for(intj = 0; j < BALLMAX; j++)            for(intk = 0; k < WICKETMAX; k++)    dp[i, j, k]=-1;      Console.WriteLine(CountWays(0, 0, 0, R, B, W, dp));}}  // This code is contributed by mits | 
Javascript
| <script>// javascript implementation of the approach    varmod = 1000000007;    varRUNMAX = 300;    varBALLMAX = 50;    varWICKETMAX = 10;      // Function to return the number of ways    // to score R runs in B balls with    // at most W wickets    functionCountWays(r , b , l , R , B , W,  dp) {          // If the wickets lost are more        if(l > W)            return0;          // If runs scored are more        if(r > R)            return0;          // If condition is met        if(b == B && r == R)            return1;          // If no run got scored        if(b == B)            return0;          // Already visited state        if(dp[r][b][l] != -1)            returndp[r][b][l];          varans = 0;          // If scored 0 run        ans += CountWays(r, b + 1, l, R, B, W, dp);        ans = ans % mod;          // If scored 1 run        ans += CountWays(r + 1, b + 1, l, R, B, W, dp);        ans = ans % mod;          // If scored 2 runs        ans += CountWays(r + 2, b + 1, l, R, B, W, dp);        ans = ans % mod;          // If scored 3 runs        ans += CountWays(r + 3, b + 1, l, R, B, W, dp);        ans = ans % mod;          // If scored 4 runs        ans += CountWays(r + 4, b + 1, l, R, B, W, dp);        ans = ans % mod;          // If scored 6 runs        ans += CountWays(r + 6, b + 1, l, R, B, W, dp);        ans = ans % mod;          // If scored no run and lost a wicket        ans += CountWays(r, b + 1, l + 1, R, B, W, dp);        ans = ans % mod;          // Memoize and return        returndp[r][b][l] = ans;    }      // Driver code            varR = 40, B = 10, W = 4;          vardp = Array(RUNMAX).fill().map(()=>Array(BALLMAX).fill().map(()=>Array(WICKETMAX).fill(0)));        for(i = 0; i < RUNMAX; i++)            for(j = 0; j < BALLMAX; j++)                for(k = 0; k < WICKETMAX; k++)                    dp[i][j][k] = -1;          document.write(CountWays(0, 0, 0, R, B, W, dp));  // This code is contributed by umadevi9616</script> | 
653263
Â
Time Complexity: O(r*b*w), as we are using recursion with memorization, so we will avoid redundant function calls and the complexity will be O(r*b*w)
Auxiliary Space: O(300*50*10), as we are using extra space for the dp matrix.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!


 
                                    







