Codestin Search App

Word Pattern II - Problem

Word Pattern II is a fascinating pattern matching problem that challenges you to determine if a string can be split and mapped to match a given pattern.

You are given:

pattern - A string of lowercase letters (e.g., "abab")
s - A target string to match (e.g., "redblueredblue")

Goal: Return true if s matches the pattern through a bijective mapping.

What is a bijective mapping?

Each pattern character maps to exactly one non-empty substring
No two pattern characters can map to the same substring
Each pattern character must consistently map to the same substring

Example: Pattern "abab" and string "redblueredblue"

'a' → "red" and 'b' → "blue"
This creates: "red" + "blue" + "red" + "blue" = "redblueredblue" ✓

Input & Output

example_1.py — Python

$ Input: pattern = "abab", s = "redblueredblue"

› Output: true

💡 Note: We can map 'a' to 'red' and 'b' to 'blue'. This gives us: 'red' + 'blue' + 'red' + 'blue' = 'redblueredblue', which matches the input string perfectly.

example_2.py — Python

$ Input: pattern = "aaaa", s = "asdasdasdasd"

› Output: true

💡 Note: We can map 'a' to 'asd'. This gives us: 'asd' + 'asd' + 'asd' + 'asd' = 'asdasdasdasd', which matches the input string.

example_3.py — Python

$ Input: pattern = "abab", s = "asdasdasdasd"

› Output: false

💡 Note: There's no way to create a bijective mapping. If we try 'a' → 'asd' and 'b' → 'asd', this violates the bijective constraint (two different characters cannot map to the same substring).

Constraints

1 ≤ pattern.length ≤ 20
1 ≤ s.length ≤ 50
pattern contains only lowercase English letters
s contains only lowercase English letters
Each pattern character must map to a non-empty substring

Visualization

Tap to expand

Understanding the Visualization

Start Decoding

Begin with pattern 'abab' and encrypted text 'redblueredblue'

First Mapping

Try mapping first 'a' to different substrings: 'r', 're', 'red'...

Consistent Check

When 'a' appears again, verify it maps to the same substring

Bijective Validation

Ensure no two different symbols map to the same word

Complete Match

Success when all symbols are consistently mapped and string is fully consumed

Key Takeaway

🎯 Key Insight: Use backtracking with bidirectional hash maps to maintain bijective constraints while exploring all possible substring mappings efficiently

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses backtracking with hash tables to explore all possible mappings while maintaining bijective constraints. Key optimizations include early pruning based on length constraints and O(1) lookups for existing mappings. The algorithm efficiently explores the search space by maintaining both character-to-word and word-to-character mappings to ensure no conflicts occur.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Backtracking (Optimal)	O(s^p) worst case, much better in practice	O(p + m)	Enhanced backtracking with early pruning and optimizations
Backtracking with Basic Validation	O(s^p)	O(p)	Try all possible substring mappings using recursive backtracking

Optimized Backtracking (Optimal) — Algorithm Steps

Use hash maps for O(1) character-to-word and word-to-character lookups
Add length-based pruning to eliminate impossible branches early
Maintain bidirectional mapping constraints throughout recursion
Use memoization to avoid recomputing the same subproblems
Optimize substring operations for better performance

Visualization

Tap to expand

Step-by-Step Walkthrough

Length Check

First check if remaining string length is feasible

Hash Lookup

O(1) lookup for existing character mappings

Smart Bounds

Calculate maximum substring length to avoid impossible cases

Bidirectional Check

Verify both char→word and word→char mappings

Early Pruning

Exit immediately when constraints are violated

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_MAPPINGS 26

typedef struct {
    char key;
    char value[MAX_LEN];
    bool used;
} CharMapping;

typedef struct {
    char key[MAX_LEN];
    char value;
    bool used;
} WordMapping;

bool canMatch(const char* pattern, int pIdx, const char* s, int sIdx, int patternLen, int sLen) {
    int remainingPattern = patternLen - pIdx;
    int remainingString = sLen - sIdx;
    
    if (remainingPattern == 0) {
        return remainingString == 0;
    }
    return remainingString >= remainingPattern;
}

bool backtrack(const char* pattern, int pIdx, const char* s, int sIdx,
               CharMapping* charToWord, WordMapping* wordToChar, 
               int patternLen, int sLen) {
    if (!canMatch(pattern, pIdx, s, sIdx, patternLen, sLen)) {
        return false;
    }
    
    if (pIdx == patternLen) {
        return sIdx == sLen;
    }
    
    char c = pattern[pIdx];
    int charIdx = c - 'a';
    
    if (charToWord[charIdx].used) {
        char* word = charToWord[charIdx].value;
        int wordLen = strlen(word);
        if (sIdx + wordLen <= sLen && strncmp(s + sIdx, word, wordLen) == 0) {
            return backtrack(pattern, pIdx + 1, s, sIdx + wordLen, charToWord, wordToChar, patternLen, sLen);
        }
        return false;
    }
    
    int maxLen = sLen - sIdx;
    int remaining = sLen - (patternLen - pIdx - 1);
    if (remaining < maxLen) maxLen = remaining;
    
    for (int length = 1; length <= maxLen; length++) {
        char word[MAX_LEN];
        strncpy(word, s + sIdx, length);
        word[length] = '\0';
        
        bool wordExists = false;
        int freeSlot = -1;
        for (int i = 0; i < MAX_MAPPINGS; i++) {
            if (wordToChar[i].used && strcmp(wordToChar[i].key, word) == 0) {
                wordExists = true;
                break;
            }
            if (!wordToChar[i].used && freeSlot == -1) {
                freeSlot = i;
            }
        }
        if (wordExists) continue;
        
        charToWord[charIdx].key = c;
        strcpy(charToWord[charIdx].value, word);
        charToWord[charIdx].used = true;
        
        strcpy(wordToChar[freeSlot].key, word);
        wordToChar[freeSlot].value = c;
        wordToChar[freeSlot].used = true;
        
        if (backtrack(pattern, pIdx + 1, s, sIdx + length, charToWord, wordToChar, patternLen, sLen)) {
            return true;
        }
        
        charToWord[charIdx].used = false;
        wordToChar[freeSlot].used = false;
    }
    
    return false;
}

bool wordPatternMatch(const char* pattern, const char* s) {
    CharMapping charToWord[MAX_MAPPINGS] = {0};
    WordMapping wordToChar[MAX_MAPPINGS] = {0};
    return backtrack(pattern, 0, s, 0, charToWord, wordToChar, strlen(pattern), strlen(s));
}

int main() {
    char pattern[MAX_LEN], s[MAX_LEN];
    fgets(pattern, sizeof(pattern), stdin);
    fgets(s, sizeof(s), stdin);
    
    pattern[strcspn(pattern, "\n")] = 0;
    s[strcspn(s, "\n")] = 0;
    if (pattern[0] == '"') {
        memmove(pattern, pattern + 1, strlen(pattern));
        pattern[strlen(pattern) - 1] = 0;
    }
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = 0;
    }
    
    printf("%s\n", wordPatternMatch(pattern, s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(s^p) worst case, much better in practice

Worst case is still exponential, but pruning and optimizations make it much faster for practical inputs

✓ Linear Growth

Space Complexity

O(p + m)

Space for recursion stack (p) plus hash maps storing at most m unique mappings

✓ Linear Space

28.8K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Optimized Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler