Number of Music Playlists - Problem

Your music player contains n different songs. You want to listen to goal songs (not necessarily different) during your trip. To avoid boredom, you will create a playlist so that:

Every song is played at least once
A song can only be played again only if k other songs have been played

Given n, goal, and k, return the number of possible playlists that you can create. Since the answer can be very large, return it modulo 10^9 + 7.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, goal = 3, k = 1

› Output: 6

💡 Note: We have 3 songs and want a playlist of length 3. Each song must be played at least once, and we can't repeat a song until 1 other song has been played. Possible playlists: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1].

Example 2 — Higher K Value

$ Input: n = 2, goal = 3, k = 0

› Output: 6

💡 Note: With k=0, we can repeat any song immediately. We have 2 songs, need length 3, both songs used at least once. Playlists: [1,1,2], [1,2,1], [1,2,2], [2,1,1], [2,1,2], [2,2,1].

Example 3 — Impossible Case

$ Input: n = 2, goal = 3, k = 3

› Output: 0

💡 Note: With k=3, we need to play 3 other songs before repeating. But we only have 2 songs total, so it's impossible to repeat any song in a playlist of length 3.

Constraints

1 ≤ n ≤ 100
1 ≤ goal ≤ 100
0 ≤ k < n

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is to use dynamic programming where dp[i][j] represents the number of playlists of length i using exactly j unique songs. We transition by either adding a new song or repeating an existing one (if the k constraint allows). Best approach is Bottom-Up DP with Time: O(goal × n), Space: O(goal × n)

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(goal × n) Space: O(goal × n)

Define dp[i][j] as number of ways to create playlists of length i using exactly j unique songs. Use transitions based on whether we're adding a new song or repeating an existing one.

Memoization (Top-Down DP)

⏱️ Time: O(goal × 2^n × n^k) Space: O(goal × 2^n × n^k)

Use the same recursive approach but store results in a memo table. State is defined by (position, used_songs_bitmask, songs_since_last_play). This dramatically reduces repeated calculations.

Recursive Brute Force

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

For each position in the playlist, try placing each valid song and recursively count all possibilities. This explores the entire solution space without optimization.

Bottom-Up Dynamic Programming — Algorithm Steps

Initialize base cases
Fill DP table using transitions
Return dp[goal][n]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base case dp[0][0] = 1

Fill Table

For each cell, consider adding new song or repeating

Final Answer

dp[goal][n] contains the result

Code -

solution.c — C

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

#define MOD 1000000007

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

int solution(int n, int goal, int k) {
    // dp[i][j] = number of playlists of length i using exactly j unique songs
    long long dp[101][101];
    memset(dp, 0, sizeof(dp));
    
    // Base case
    dp[0][0] = 1;
    
    for (int i = 1; i <= goal; i++) {
        for (int j = 1; j <= min(i, n); j++) {
            // Case 1: Add a new song
            if (j > 0) {
                dp[i][j] = (dp[i][j] + dp[i-1][j-1] * (n - (j-1))) % MOD;
            }
            
            // Case 2: Repeat an existing song
            if (j > k) {
                dp[i][j] = (dp[i][j] + dp[i-1][j] * (j - k)) % MOD;
            }
        }
    }
    
    return dp[goal][n];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(goal × n)

Two nested loops: goal positions × number of unique songs

✓ Linear Growth

Space Complexity

O(goal × n)

2D DP table of size goal × n

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

856 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 Music Playlists - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler