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++ implementation of the approach #include <bits/stdc++.h> using namespace std;
#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 wickets int CountWays( int r, int b, int l, int R, int B, int W,
int dp[RUNMAX][BALLMAX][WICKETMAX])
{ // If the wickets lost are more
if (l > W)
return 0;
// If runs scored are more
if (r > R)
return 0;
// If condition is met
if (b == B && r == R)
return 1;
// If no run got scored
if (b == B)
return 0;
// Already visited state
if (dp[r][b][l] != -1)
return dp[r][b][l];
int 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
return dp[r][b][l] = ans;
} // Driver code int main()
{ int R = 40, B = 10, W = 4;
int dp[RUNMAX][BALLMAX][WICKETMAX];
memset (dp, -1, sizeof dp);
cout << CountWays(0, 0, 0, R, B, W, dp);
return 0;
} |
// Java implementation of the approach class GFG
{ static int mod = 1000000007 ;
static int RUNMAX = 300 ;
static int BALLMAX = 50 ;
static int WICKETMAX = 10 ;
// Function to return the number of ways // to score R runs in B balls with // at most W wickets static int CountWays( int r, int b, int l,
int R, int B, int W,
int [][][]dp)
{ // If the wickets lost are more
if (l > W)
return 0 ;
// If runs scored are more
if (r > R)
return 0 ;
// If condition is met
if (b == B && r == R)
return 1 ;
// If no run got scored
if (b == B)
return 0 ;
// Already visited state
if (dp[r][b][l] != - 1 )
return dp[r][b][l];
int 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
return dp[r][b][l] = ans;
} // Driver code public static void main(String[] args)
{ int R = 40 , B = 10 , W = 4 ;
int [][][] dp = new int [RUNMAX][BALLMAX][WICKETMAX];
for ( int i = 0 ; i < RUNMAX;i++)
for ( int j = 0 ; j < BALLMAX; j++)
for ( int k = 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 implementation of the approach mod = 1000000007
RUNMAX = 300
BALLMAX = 50
WICKETMAX = 10
# Function to return the number of ways # to score R runs in B balls with # at most W wickets def CountWays(r, b, l, R, B, W, dp):
# If the wickets lost are more
if (l > W):
return 0 ;
# If runs scored are more
if (r > R):
return 0 ;
# If condition is met
if (b = = B and r = = R):
return 1 ;
# If no run got scored
if (b = = B):
return 0 ;
# Already visited state
if (dp[r][b][l] ! = - 1 ):
return dp[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
return ans;
# Driver code if __name__ = = "__main__" :
R = 40
B = 10
W = 40
dp = [[[ - 1 for k in range (WICKETMAX)]
for j in range (BALLMAX)]
for i in range (RUNMAX)]
print (CountWays( 0 , 0 , 0 , R, B, W, dp))
# This code is contributed by rutvik_56 |
// C# implementation of the approach using System;
using System.Collections.Generic;
using System.Linq;
class GFG
{ static int mod = 1000000007;
static int RUNMAX = 300;
static int BALLMAX = 50;
static int WICKETMAX = 10;
// Function to return the number of ways // to score R runs in B balls with // at most W wickets static int CountWays( int r, int b, int l,
int R, int B, int W,
int [,,]dp)
{ // If the wickets lost are more
if (l > W)
return 0;
// If runs scored are more
if (r > R)
return 0;
// If condition is met
if (b == B && r == R)
return 1;
// If no run got scored
if (b == B)
return 0;
// Already visited state
if (dp[r, b, l] != -1)
return dp[r, b, l];
int 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
return dp[r, b, l] = ans;
} // Driver code static void Main()
{ int R = 40, B = 10, W = 4;
int [,,] dp = new int [RUNMAX, BALLMAX, WICKETMAX];
for ( int i = 0; i < RUNMAX;i++)
for ( int j = 0; j < BALLMAX; j++)
for ( int k = 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 |
<script> // javascript implementation of the approach var mod = 1000000007;
var RUNMAX = 300;
var BALLMAX = 50;
var WICKETMAX = 10;
// Function to return the number of ways
// to score R runs in B balls with
// at most W wickets
function CountWays(r , b , l , R , B , W, dp) {
// If the wickets lost are more
if (l > W)
return 0;
// If runs scored are more
if (r > R)
return 0;
// If condition is met
if (b == B && r == R)
return 1;
// If no run got scored
if (b == B)
return 0;
// Already visited state
if (dp[r][b][l] != -1)
return dp[r][b][l];
var 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
return dp[r][b][l] = ans;
}
// Driver code
var R = 40, B = 10, W = 4;
var dp = 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.