Count Ways to Distribute Candies - Practice Coding Problems

Count Ways to Distribute Candies - Problem

Dynamic Programming Hard

Imagine you're organizing a candy distribution event where you need to divide n unique candies (labeled 1 through n) into k bags such that every bag contains at least one candy.

The challenge is to count how many different ways you can accomplish this distribution. Two distributions are considered different if there exists at least one pair of candies that are together in one distribution but separated in another.

Key Rules:

Every bag must contain at least one candy
The order of bags doesn't matter: (1), (2,3) ≡ (2,3), (1)
The order within bags doesn't matter: (2,3) ≡ (3,2)
But groupings matter: (1), (2,3) ≠ (1,2), (3)

Example: With candies [1,2,3] and 2 bags, valid distributions are: (1), (2,3), (2), (1,3), and (3), (1,2) — that's 3 ways total.

Return the result modulo 10⁹ + 7 as the answer can be very large.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, k = 2

› Output: 3

💡 Note: With 3 candies and 2 bags, we can distribute as: (1),(2,3) or (2),(1,3) or (3),(1,2). That's 3 different ways.

example_2.py — Equal Distribution

$ Input: n = 4, k = 4

› Output: 1

💡 Note: With 4 candies and 4 bags, there's only one way: each candy goes in its own bag (1),(2),(3),(4).

example_3.py — Impossible Case

$ Input: n = 2, k = 3

› Output: 0

💡 Note: Cannot distribute 2 candies into 3 non-empty bags - it's impossible, so return 0.

Constraints

1 ≤ n ≤ 1000
1 ≤ k ≤ 1000
Answer fits in 32-bit signed integer after taking modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

This is counting set partitions - Stirling numbers of second kind S(n,k)

Set Up Recurrence

S(n,k) = k×S(n-1,k) + S(n-1,k-1) - either join existing group or form new one

Build DP Table

Fill table bottom-up using base cases and recurrence relation

Return Answer

S(n,k) gives the exact count we need, modulo 10^9+7

Key Takeaway

🎯 Key Insight: This is a classic application of Stirling numbers of the second kind, solved efficiently with dynamic programming in O(n×k) time.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

This problem is solved using Stirling numbers of the second kind with dynamic programming. The key insight is recognizing that distributing n unique candies into k non-empty bags is equivalent to partitioning a set of n elements into k non-empty subsets. Use the recurrence relation S(n,k) = k×S(n-1,k) + S(n-1,k-1) to build the solution efficiently in O(n×k) time.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Stirling Numbers)	O(n*k)	O(n*k)	Use dynamic programming to compute Stirling numbers of the second kind S(n,k)

Dynamic Programming (Stirling Numbers) — Algorithm Steps

Recognize this is a Stirling numbers of second kind problem
Create DP table where dp[i][j] = S(i,j)
Use recurrence: S(n,k) = k*S(n-1,k) + S(n-1,k-1)
Base cases: S(0,0) = 1, S(n,0) = 0 for n>0, S(0,k) = 0 for k>0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize base case

Set dp[0][0] = 1, all other entries to 0

Fill table row by row

For each cell dp[i][j], use recurrence S(i,j) = j*S(i-1,j) + S(i-1,j-1)

Build up solutions

Each entry represents ways to partition i items into j groups

Return final answer

dp[n][k] contains the number of ways to distribute n candies into k bags

Code -

solution.c — C

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

#define MOD 1000000007

long long distributeCandies(int n, int k) {
    if (k > n || k == 0) return 0;
    if (k == n) return 1;
    
    // Allocate dp table
    long long** dp = (long long**)malloc((n + 1) * sizeof(long long*));
    for (int i = 0; i <= n; i++) {
        dp[i] = (long long*)calloc(k + 1, sizeof(long long));
    }
    
    // Base case
    dp[0][0] = 1;
    
    for (int i = 1; i <= n; i++) {
        int maxJ = i < k ? i : k;
        for (int j = 1; j <= maxJ; j++) {
            // S(n,k) = k*S(n-1,k) + S(n-1,k-1)
            dp[i][j] = ((long long)j * dp[i-1][j] % MOD + dp[i-1][j-1]) % MOD;
        }
    }
    
    long long result = dp[n][k];
    
    // Free memory
    for (int i = 0; i <= n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We fill an n×k DP table, each cell computed in O(1) time

✓ Linear Growth

Space Complexity

O(n*k)

DP table of size n×k, can be optimized to O(k) using 1D array

⚡ Linearithmic Space

21.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Stirling Numbers) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler