Number of Dice Rolls With Target Sum - Problem

Dynamic Programming Medium

You have n dice, and each dice has k faces numbered from 1 to k.

Given three integers n, k, and target, return the number of possible ways (out of the k^n total ways) to roll the dice, so the sum of the face-up numbers equals target.

Since the answer may be too large, return it modulo 10^9 + 7.

Input & Output

Example 1 — Basic Case

$ Input: n = 1, k = 6, target = 3

› Output: 1

💡 Note: With 1 die having 6 faces, only one way to get sum 3: roll a 3

Example 2 — Multiple Ways

$ Input: n = 2, k = 6, target = 7

› Output: 6

💡 Note: With 2 dice, 6 ways to get sum 7: (1,6), (2,5), (3,4), (4,3), (5,2), (6,1)

Example 3 — Impossible Target

$ Input: n = 30, k = 30, target = 500

› Output: 222616187

💡 Note: Large case with many combinations, result modulo 10^9 + 7

Constraints

1 ≤ n, k ≤ 30
1 ≤ target ≤ 1000

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

This problem uses dynamic programming to count ways to achieve a target sum with dice rolls. The key insight is that each state depends on the number of dice remaining and the current sum. Best approach is 1D space-optimized DP. Time: O(n × target × k), Space: O(target).

Common Approaches

✓ Bottom-Up 2D Dynamic Programming

⏱️ Time: O(n × target × k) Space: O(n × target)

Create a 2D DP table where dp[i][j] represents the number of ways to achieve sum j using i dice. Fill the table bottom-up, starting from base cases and building up to the final answer.

Brute Force Recursion

⏱️ Time: O(k^n) Space: O(n)

Generate all possible combinations of dice rolls and count those that sum to target. For each die, try all faces from 1 to k and recursively solve for remaining dice.

Memoization (Top-Down DP)

⏱️ Time: O(n × target × k) Space: O(n × target)

Use recursion with memoization to store results of subproblems. Each state is defined by (dice_left, current_sum), and we cache the result to avoid recalculating the same subproblem multiple times.

Space-Optimized 1D Dynamic Programming

⏱️ Time: O(n × target × k) Space: O(target)

Since each row in the DP table only depends on the previous row, we can optimize space by using just two 1D arrays instead of a full 2D table. This reduces space complexity while maintaining the same time complexity.

Bottom-Up 2D Dynamic Programming — Algorithm Steps

Initialize DP table: dp[i][j] = ways to get sum j with i dice
Base case: dp[0][0] = 1 (one way to get sum 0 with 0 dice)
Fill table: dp[i][j] = sum of dp[i-1][j-face] for all valid faces

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][0] = 1, all others = 0

Fill Row

For each dice count, calculate all possible sums

Result

Answer is dp[n][target]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const int MOD = 1000000007;

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(int n, int k, int target) {
    // dp[i][j] = ways to get sum j using i dice
    int dp[31][1001];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = 1;  // Base case: 0 dice, sum 0 = 1 way
    
    for (int dice = 1; dice <= n; dice++) {
        for (int s = 1; s <= target; s++) {
            for (int face = 1; face <= min(k, s); face++) {
                dp[dice][s] = (dp[dice][s] + dp[dice - 1][s - face]) % MOD;
            }
        }
    }
    
    return dp[n][target];
}

int main() {
    int n, k, target;
    scanf("%d %d %d", &n, &k, &target);
    printf("%d\n", solution(n, k, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × target × k)

Three nested loops: n dice, target sums, and k face values

✓ Linear Growth

Space Complexity

O(n × target)

2D DP table stores results for all (dice count, sum) combinations

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Number of Dice Rolls With Target Sum - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up 2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler