Word Pattern II

Word Pattern II - Problem

Given a pattern and a string s, return true if s matches the pattern.

A string s matches a pattern if there is some bijective mapping of single characters to non-empty strings such that if each character in pattern is replaced by the string it maps to, then the resulting string is s.

A bijective mapping means that:

No two characters map to the same string
No character maps to two different strings

Input & Output

Example 1 — Basic Pattern Match

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

› Output: true

💡 Note: One possible mapping: a → 'red', b → 'blue'. This creates 'red' + 'blue' + 'red' + 'blue' = 'redblueredblue'

Example 2 — No Valid Mapping

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

› Output: true

💡 Note: Pattern 'aaaa' can map a → 'asd' to create 'asd' + 'asd' + 'asd' + 'asd' = 'asdasdasdasd'

Example 3 — Bijection Violation

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

› Output: false

💡 Note: No bijective mapping exists. For example, trying a → 'as', b → 'df' gives 'as' + 'df' + 'as' + 'df' = 'asdfasdf' ≠ 'asdfhjkl'. All other possible mappings also fail to produce the target string.

Constraints

1 ≤ pattern.length ≤ 20
1 ≤ s.length ≤ 50
pattern contains only lowercase English letters
s contains only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 F Facebook 20 a Amazon 15

The key insight is using backtracking to build character-to-string mappings while ensuring bijection (one-to-one mapping). Best approach is backtracking with pruning for early conflict detection. Time: O(m^n), Space: O(n).

Common Approaches

✓ Backtracking with Pruning

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

Start from the first character in pattern and try different substring lengths from string s. Build character-to-string mappings incrementally. Backtrack immediately when conflicts are detected (bijection violation).

Brute Force - Try All Partitions

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

For each position in the pattern, try all possible substring lengths from the remaining string. Check if the resulting mapping is bijective (one-to-one). This explores every possible partition of the string.

Backtracking with Pruning — Algorithm Steps

Start with first character in pattern
Try different substring lengths from current position in s
Check if mapping conflicts with existing mappings
If valid, recurse to next character; if conflict, backtrack
Return true if all characters mapped successfully

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Mapping

For current pattern character, try different substring lengths

Check Conflicts

Verify bijection property before proceeding

Backtrack

Remove mapping and try next possibility if conflict found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.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;
} StringMapping;

bool backtrack(const char* pattern, const char* s, int pIdx, int sIdx,
               CharMapping* charToStr, StringMapping* strToChar, int patternLen, int sLen) {
    if (pIdx == patternLen) {
        return sIdx == sLen;
    }
    if (sIdx >= sLen) {
        return false;
    }
    
    char ch = pattern[pIdx];
    int chIdx = ch - 'a';
    
    if (charToStr[chIdx].used) {
        const char* mappedStr = charToStr[chIdx].value;
        int mappedLen = strlen(mappedStr);
        if (sIdx + mappedLen <= sLen && strncmp(s + sIdx, mappedStr, mappedLen) == 0) {
            return backtrack(pattern, s, pIdx + 1, sIdx + mappedLen, charToStr, strToChar, patternLen, sLen);
        } else {
            return false;
        }
    }
    
    for (int end = sIdx + 1; end <= sLen; end++) {
        char substring[MAX_LEN];
        int subLen = end - sIdx;
        strncpy(substring, s + sIdx, subLen);
        substring[subLen] = '\0';
        
        // Check if substring already mapped
        bool alreadyMapped = false;
        for (int i = 0; i < MAX_MAPPINGS; i++) {
            if (strToChar[i].used && strcmp(strToChar[i].key, substring) == 0) {
                alreadyMapped = true;
                break;
            }
        }
        
        if (alreadyMapped) continue;
        
        // Add mapping
        charToStr[chIdx].used = true;
        charToStr[chIdx].key = ch;
        strcpy(charToStr[chIdx].value, substring);
        
        int freeSlot = -1;
        for (int i = 0; i < MAX_MAPPINGS; i++) {
            if (!strToChar[i].used) {
                freeSlot = i;
                break;
            }
        }
        
        if (freeSlot >= 0) {
            strToChar[freeSlot].used = true;
            strcpy(strToChar[freeSlot].key, substring);
            strToChar[freeSlot].value = ch;
            
            if (backtrack(pattern, s, pIdx + 1, end, charToStr, strToChar, patternLen, sLen)) {
                return true;
            }
            
            // Backtrack
            charToStr[chIdx].used = false;
            strToChar[freeSlot].used = false;
        }
    }
    
    return false;
}

bool solution(char* pattern, char* s) {
    int patternLen = strlen(pattern);
    int sLen = strlen(s);
    
    if (patternLen == 0) return sLen == 0;
    if (sLen == 0) return false;
    
    CharMapping charToStr[MAX_MAPPINGS];
    StringMapping strToChar[MAX_MAPPINGS];
    
    for (int i = 0; i < MAX_MAPPINGS; i++) {
        charToStr[i].used = false;
        strToChar[i].used = false;
    }
    
    return backtrack(pattern, s, 0, 0, charToStr, strToChar, patternLen, sLen);
}

int main() {
    char pattern[MAX_LEN], s[MAX_LEN];
    
    fgets(pattern, sizeof(pattern), stdin);
    pattern[strcspn(pattern, "\n")] = 0;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    bool result = solution(pattern, s);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m^n)

For pattern length n and string length m, each position can try up to m substrings

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth is pattern length, plus hash maps store at most n mappings

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler