Count Ways to Distribute Candies

Count Ways to Distribute Candies - Problem

Dynamic Programming Hard

There are n unique candies (labeled 1 through n) and k bags. You are asked to distribute all the candies into the bags such that every bag has at least one candy.

There can be multiple ways to distribute the candies. Two ways are considered different if the candies in one bag in the first way are not all in the same bag in the second way. The order of the bags and the order of the candies within each bag do not matter.

For example, (1), (2,3) and (2), (1,3) are considered different because candies 2 and 3 in the bag (2,3) in the first way are not in the same bag in the second way (they are split between the bags (2) and (1,3)). However, (1), (2,3) and (3,2), (1) are considered the same because the candies in each bag are all in the same bags in both ways.

Given two integers, n and k, return the number of different ways to distribute the candies. As the answer may be too large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, k = 2

› Output: 3

💡 Note: 3 ways to distribute 3 candies into 2 non-empty bags: (1),(2,3) or (2),(1,3) or (3),(1,2)

Example 2 — Equal Partitions

$ Input: n = 2, k = 1

› Output: 1

💡 Note: Only 1 way: put both candies (1,2) in the single bag

Example 3 — Each in Own Bag

$ Input: n = 4, k = 4

› Output: 1

💡 Note: Only 1 way: each candy goes in its own bag (1),(2),(3),(4)

Constraints

1 ≤ n ≤ 1000
1 ≤ k ≤ 1000
Answer modulo 10⁹ + 7

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

This problem asks for Stirling numbers of the second kind S(n,k) - the number of ways to partition n distinct objects into k non-empty subsets. The optimal approach uses dynamic programming with the recurrence relation: S(n,k) = k×S(n-1,k) + S(n-1,k-1). Time: O(n×k), Space: O(k) with space optimization.

Common Approaches

✓ 2D Dynamic Programming

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

Use dynamic programming where dp[i][j] represents ways to partition i candies into j non-empty bags. This computes Stirling numbers of the second kind efficiently.

Brute Force Recursion

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

For each candy, try placing it in each of the k bags. Use recursion to explore all possibilities and count valid distributions where every bag has at least one candy.

Space-Optimized 1D DP

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

Since each row only depends on the previous row, we can optimize space by using two 1D arrays instead of a 2D table, alternating between them.

2D Dynamic Programming — Algorithm Steps

Initialize dp table with base cases
Fill table using recurrence relation
Return dp[n][k] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

Initialize dp[i][1]=1 and dp[i][i]=1

Fill Table

dp[i][j] = j×dp[i-1][j] + dp[i-1][j-1]

Result

Return dp[n][k]

Code -

solution.c — C

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

const int MOD = 1000000007;

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

int solution(int n, int k) {
    if (n == 0 || k == 0 || k > n) {
        return 0;
    }
    if (k == 1 || 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 cases
    for (int i = 1; i <= n; i++) {
        dp[i][1] = 1;
        if (i <= k) {
            dp[i][i] = 1;
        }
    }
    
    // Fill the dp table
    for (int i = 2; i <= n; i++) {
        for (int j = 2; j <= min(i, k); j++) {
            dp[i][j] = (j * dp[i-1][j] + dp[i-1][j-1]) % MOD;
        }
    }
    
    int 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", &n);
    scanf("%d", &k);
    printf("%d\n", solution(n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

Two nested loops to fill the dp table

✓ Linear Growth

Space Complexity

O(n*k)

2D dp table of size n×k

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler