Stickers to Spell Word

Stickers to Spell Word - Problem

Array Hash Table String Dynamic Programming Backtracking Bit Manipulation Memoization Bitmask Hard

You are given n different types of stickers. Each sticker has a lowercase English word on it.

You would like to spell out the given string target by cutting individual letters from your collection of stickers and rearranging them. You can use each sticker more than once if you want, and you have infinite quantities of each sticker.

Return the minimum number of stickers that you need to spell out target. If the task is impossible, return -1.

Note: In all test cases, all words were chosen randomly from the 1000 most common US English words, and target was chosen as a concatenation of two random words.

Input & Output

Example 1 — Basic Case

$ Input: stickers = ["with","example","science"], target = "thehat"

› Output: 3

💡 Note: We can use 2 "science" stickers (giving us 's', 'c', 'i', 'e', 'n', 'c', 'e') and 1 "example" sticker (giving us 'e', 'x', 'a', 'm', 'p', 'l', 'e') to spell "thehat". We need 't', 'h', 'e', 'h', 'a', 't'. From "science" we get 'e'. From "example" we get 'e', 'a'. We still need another approach - actually need "with" for 'w','i','t','h' and more stickers.

Example 2 — Simple Case

$ Input: stickers = ["notice","possible"], target = "basicall"

› Output: -1

💡 Note: We cannot spell "basicall" because we need 'r' and 'y' which are not available in any sticker, making it impossible.

Example 3 — Multiple Solutions

$ Input: stickers = ["these","guess","about","garden","him"], target = "atomher"

› Output: 3

💡 Note: We can use "about" (a,b,o,u,t), "these" (t,h,e,s,e), "him" (h,i,m) to get enough letters. From "about" we get 'a','t','o'. From "these" we get 'h','e'. From "garden" we get 'r'. This gives us all letters for "atomher".

Constraints

n == stickers.length
1 ≤ n ≤ 50
1 ≤ stickers[i].length ≤ 10
1 ≤ target.length ≤ 15
stickers[i] and target consist of lowercase English letters

Visualization

Tap to expand

Asked in

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

The key insight is to use dynamic programming with memoization to avoid recalculating the same letter combinations. We can represent the remaining target as a sorted string or frequency count. The optimal approach uses memoized recursion with state compression. Time: O(2^n × m), Space: O(2^n)

Common Approaches

✓ Dynamic Programming with Bitmask

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

Represent the target state as a bitmask where each bit indicates if a position in the target is satisfied. Use DP to find the minimum stickers needed for each possible state.

Memoized Recursion

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

Same recursive approach but cache results for identical remaining letter combinations. Since order doesn't matter, we can represent state as sorted string or frequency count.

Recursive Backtracking

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

For each remaining target, try using each sticker and recursively solve for the remaining letters. This explores all possible ways to use stickers without any pruning or memoization.

Dynamic Programming with Bitmask — Algorithm Steps

Create bitmask representation of target positions
For each state, try each sticker
Update reachable states with one more sticker
Return DP value for complete state

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[0] = 0, all others = ∞

Try Stickers

For each state, apply each sticker

Update Mask

Set bits for satisfied positions

Final State

dp[11111] gives minimum stickers

Code -

solution.c — C

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

int solution(char stickers[][50], int stickerCount, char* target) {
    int n = strlen(target);
    if (n > 20) return -1;

    int maxMask = 1 << n;
    int* dp = (int*)malloc(maxMask * sizeof(int));
    for (int i = 0; i < maxMask; i++) dp[i] = INT_MAX;
    dp[0] = 0;

    for (int mask = 0; mask < maxMask; mask++) {
        if (dp[mask] == INT_MAX) continue;

        for (int s = 0; s < stickerCount; s++) {
            int newMask = mask;
            int sCount[26] = {0};
            for (int j = 0; j < (int)strlen(stickers[s]); j++) {
                sCount[stickers[s][j] - 'a']++;
            }

            for (int i = 0; i < n; i++) {
                if ((newMask & (1 << i)) == 0) {
                    char ch = target[i];
                    if (sCount[ch - 'a'] > 0) {
                        sCount[ch - 'a']--;
                        newMask |= (1 << i);
                    }
                }
            }

            if (dp[mask] + 1 < dp[newMask]) {
                dp[newMask] = dp[mask] + 1;
            }
        }
    }

    int fullMask = (1 << n) - 1;
    int result = dp[fullMask] == INT_MAX ? -1 : dp[fullMask];
    free(dp);
    return result;
}

int main() {
    char line[2000];
    fgets(line, sizeof(line), stdin);

    char stickers[50][50];
    int stickerCount = 0;

    // Parse JSON array: ["word1","word2",...]
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;

    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',' || *ptr == '\t') ptr++;
        if (*ptr == ']' || *ptr == '\0') break;

        if (*ptr == '"') {
            ptr++; // skip opening quote
            int len = 0;
            // Read until closing quote
            while (*ptr && *ptr != '"') {
                stickers[stickerCount][len++] = *ptr++;
            }
            stickers[stickerCount][len] = '\0';
            if (*ptr == '"') ptr++; // skip closing quote
            stickerCount++;
        } else {
            ptr++;
        }
    }

    char target[100];
    fgets(target, sizeof(target), stdin);
    target[strcspn(target, "\n")] = 0;

    int result = solution(stickers, stickerCount, target);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m × n)

2^n possible states, m stickers to try, n characters to match per sticker

⚠ Quadratic Growth

Space Complexity

O(2^n)

DP array stores minimum stickers for each of 2^n possible states

⚡ Linearithmic Space

28.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 with Bitmask — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler