Stickers to Spell Word - Practice Coding Problems

Stickers to Spell Word - Problem

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

Imagine you have a collection of stickers, each containing a word made of lowercase English letters. Your goal is to spell out a given target string by cutting individual letters from these stickers and rearranging them.

The Rules:

You can use each sticker multiple times (infinite quantities available)
You can cut out individual letters from any sticker
You need to find the minimum number of stickers required
If it's impossible to spell the target, return -1

Example: If you have stickers ["with", "example", "science"] and want to spell "thehat", you could use:

1 × "the" sticker → get 't', 'h', 'e'
1 × "example" sticker → get 'e'
1 × "science" → not needed

This would require 2 stickers minimum to spell "thehat".

Input & Output

example_1.py — Basic case

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

› Output: 3

💡 Note: We can use 1 "with" sticker (provides t, h), 1 "example" sticker (provides e, a), and 1 "science" sticker (provides h, t). Total: 3 stickers.

example_2.py — Impossible case

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

› Output: -1

💡 Note: The target contains 'x' which doesn't appear in any sticker, making it impossible to spell the target word.

example_3.py — Single sticker repeated

$ Input: stickers = ["aa", "bb"], target = "aaaa"

› Output: 2

💡 Note: We need 2 "aa" stickers to get 4 'a' characters total to spell "aaaa".

Visualization

Tap to expand

Understanding the Visualization

Count Target Letters

First, count how many of each letter we need from the target string

Try Each Sticker

For each sticker, see which target letters it can provide

Recursive Subproblems

After using a sticker, solve for the remaining letters needed

Memoize States

Cache results to avoid recomputing the same letter count combinations

Key Takeaway

🎯 Key Insight: Convert the problem to character counting and use memoization on character count states to avoid redundant computations. The order of characters doesn't matter - only the counts do!

Time & Space Complexity

Time Complexity

⏱️

O(N * 2^T)

Where N is number of stickers and T is target length. Each unique character count state is computed once.

✓ Linear Growth

Space Complexity

O(2^T)

Space for memoization table storing all possible character count combinations

✓ Linear Space

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

Asked in

G Google 42 a Amazon 38 f Meta 24 ⊞ Microsoft 18

The optimal approach uses Dynamic Programming with Memoization on character count states. Convert the target to character counts, then recursively try each sticker while memoizing results for each unique remaining character combination. This avoids recomputing the same states and achieves O(N × 2^T) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(N * 2^T)	O(2^T)	Use DP with memoization on character counts to avoid recomputing same states
Brute Force with Backtracking	O(S^T)	O(T)	Try all possible combinations of stickers using recursive backtracking

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Convert target string to character count map
Use recursive function with memoization on remaining character counts
For each state, try each sticker and recursively solve remaining characters
Use string representation of character counts as memoization key
Return cached result if state has been computed before

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Count State

Convert problem to counting remaining characters needed

Memoization Table

Cache results for each unique character count combination

State Transitions

Try each sticker and compute new remaining character counts

Optimal Substructure

Build solution from previously computed smaller states

Code -

solution.c — C

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

#define MEMO_SIZE 10007

typedef struct {
    char key[200];
    int value;
} MemoEntry;

MemoEntry memo[MEMO_SIZE];
int memoCount = 0;

int hashCode(const char* key) {
    unsigned int hash = 5381;
    while (*key) {
        hash = ((hash << 5) + hash) + *key++;
    }
    return hash % MEMO_SIZE;
}

int getMemo(const char* key) {
    int hash = hashCode(key);
    for (int i = 0; i < memoCount; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return INT_MIN; // Not found
}

void setMemo(const char* key, int value) {
    if (memoCount < MEMO_SIZE) {
        strcpy(memo[memoCount].key, key);
        memo[memoCount].value = value;
        memoCount++;
    }
}

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

int max(int a, int b) {
    return a > b ? a : b;
}

int dp(int remaining[26], int stickerCounts[][26], int numStickers) {
    // Create key for memoization
    char key[200] = "";
    char temp[10];
    for (int i = 0; i < 26; i++) {
        sprintf(temp, "%d,", remaining[i]);
        strcat(key, temp);
    }
    
    int memoResult = getMemo(key);
    if (memoResult != INT_MIN) {
        return memoResult;
    }
    
    int allZero = 1;
    for (int i = 0; i < 26; i++) {
        if (remaining[i] > 0) {
            allZero = 0;
            break;
        }
    }
    if (allZero) {
        setMemo(key, 0);
        return 0;
    }
    
    int result = INT_MAX;
    for (int s = 0; s < numStickers; s++) {
        int canHelp = 0;
        int newRemaining[26];
        memcpy(newRemaining, remaining, sizeof(int) * 26);
        
        for (int i = 0; i < 26; i++) {
            if (remaining[i] > 0 && stickerCounts[s][i] > 0) {
                canHelp = 1;
                newRemaining[i] = max(0, remaining[i] - stickerCounts[s][i]);
            }
        }
        
        if (canHelp) {
            int subResult = dp(newRemaining, stickerCounts, numStickers);
            if (subResult != -1) {
                result = min(result, 1 + subResult);
            }
        }
    }
    
    int finalResult = result == INT_MAX ? -1 : result;
    setMemo(key, finalResult);
    return finalResult;
}

int minStickers(char stickers[][20], int numStickers, char* target) {
    // Preprocess stickers
    int stickerCounts[numStickers][26];
    memset(stickerCounts, 0, sizeof(stickerCounts));
    
    for (int i = 0; i < numStickers; i++) {
        for (int j = 0; stickers[i][j]; j++) {
            stickerCounts[i][stickers[i][j] - 'a']++;
        }
    }
    
    // Convert target to count array
    int targetCount[26] = {0};
    for (int i = 0; target[i]; i++) {
        targetCount[target[i] - 'a']++;
    }
    
    return dp(targetCount, stickerCounts, numStickers);
}

int main() {
    printf("DP Solution ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N * 2^T)

Where N is number of stickers and T is target length. Each unique character count state is computed once.

✓ Linear Growth

Space Complexity

O(2^T)

Space for memoization table storing all possible character count combinations

✓ Linear Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler