Playlist Shuffle Validator - Problem

Advanced DP DP String Hard

Given two original playlists playlist1 and playlist2, and a merged playlist merged, determine if the merged playlist is a valid interleaving of the two original playlists.

A valid interleaving means that all songs from both playlists appear in the merged playlist while preserving their relative order from the original playlists. Songs can be interleaved in any pattern, but the order within each original playlist must remain intact.

Example: If playlist1 = ["A", "B"] and playlist2 = ["X", "Y"], then ["A", "X", "B", "Y"] is valid because A comes before B (preserving playlist1 order) and X comes before Y (preserving playlist2 order).

Input & Output

Example 1 — Valid Interleaving

$ Input: playlist1 = ["A", "B"], playlist2 = ["X", "Y"], merged = ["A", "X", "B", "Y"]

› Output: true

💡 Note: The merged playlist preserves order: A comes before B (playlist1 order) and X comes before Y (playlist2 order). Valid interleaving pattern.

Example 2 — Invalid Order

$ Input: playlist1 = ["A", "B"], playlist2 = ["X", "Y"], merged = ["A", "Y", "B", "X"]

› Output: false

💡 Note: Y appears before X in merged, but playlist2 has X before Y. This violates the relative order requirement.

Example 3 — All From One Playlist First

$ Input: playlist1 = ["Rock", "Pop"], playlist2 = ["Jazz"], merged = ["Rock", "Pop", "Jazz"]

› Output: true

💡 Note: All songs from playlist1 appear first, then playlist2. Both maintain their relative order, so this is valid.

Constraints

1 ≤ playlist1.length, playlist2.length ≤ 100
1 ≤ playlist1[i].length, playlist2[i].length ≤ 10
playlist1[i], playlist2[i] consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Meta 28

The key insight is recognizing this as a classic interleaving problem that can be solved with dynamic programming. We need to track positions in both original playlists while processing the merged playlist. The optimal 2D DP approach builds a table where each cell represents whether we can form a prefix of the merged playlist using prefixes from both original playlists. Time: O(m×n), Space: O(m×n).

Common Approaches

✓ 2D Dynamic Programming

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

Create a 2D DP table where dp[i][j] represents whether we can form the first (i+j) characters of merged using first i characters from playlist1 and first j from playlist2.

Dynamic Programming with Memoization

⏱️ Time: O(m×n×(m+n)) Space: O(m×n×(m+n))

Use the same recursive approach but store results in a memoization table to avoid recalculating the same subproblems multiple times.

Recursive Backtracking

⏱️ Time: O(2^(m+n)) Space: O(m+n)

For each position in merged playlist, recursively try assigning the song to either playlist1 or playlist2, checking if the assignment maintains the correct order in both playlists.

2D Dynamic Programming — Algorithm Steps

Create DP table dp[m+1][n+1] where m,n are playlist lengths
Initialize base cases: dp[0][0] = true
Fill table: dp[i][j] = true if we can reach this state
Check transitions from dp[i-1][j] or dp[i][j-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][0] = true (base case)

Fill Table

For each cell, check both playlist transitions

Final Answer

Check dp[m][n] for complete solution

Code -

solution.c — C

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

bool solution(char playlist1[][100], int len1, char playlist2[][100], int len2, char merged[][100], int lenM) {
    if (lenM != len1 + len2) {
        return false;
    }
    
    bool dp[len1 + 1][len2 + 1];
    memset(dp, false, sizeof(dp));
    dp[0][0] = true;
    
    for (int i = 0; i <= len1; i++) {
        for (int j = 0; j <= len2; j++) {
            if (dp[i][j]) {
                if (i < len1 && strcmp(merged[i + j], playlist1[i]) == 0) {
                    dp[i + 1][j] = true;
                }
                if (j < len2 && strcmp(merged[i + j], playlist2[j]) == 0) {
                    dp[i][j + 1] = true;
                }
            }
        }
    }
    
    return dp[len1][len2];
}

int main() {
    char playlist1[100][100], playlist2[100][100], merged[200][100];
    int len1 = 0, len2 = 0, lenM = 0;
    
    // Simple parsing would go here
    
    bool result = solution(playlist1, len1, playlist2, len2, merged, lenM);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Nested loops iterate through all positions in both playlists

✓ Linear Growth

Space Complexity

O(m×n)

2D DP table stores boolean for each (i,j) state combination

⚡ Linearithmic Space

23.5K Views

Medium-High Frequency

~25 min Avg. Time

987 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

Playlist Shuffle Validator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler