Maximum Product of Word Lengths - Problem

Given a string array words, return the maximum value of length(word[i]) * length(word[j]) where the two words do not share common letters.

If no such two words exist, return 0.

Input & Output

Example 1 — Basic Case

$ Input: words = ["abcw","baz","foo","bar","xtfn","abcdef"]

› Output: 16

💡 Note: The two words can be "abcw" and "xtfn". "abcw" has letters {a,b,c,w} and "xtfn" has letters {x,t,f,n}. No common letters, so product = 4 × 4 = 16.

Example 2 — No Valid Pairs

$ Input: words = ["a","ab","abc","d","cd","bcd","abcd"]

› Output: 4

💡 Note: The two words can be "ab" and "cd". "ab" has letters {a,b} and "cd" has letters {c,d}. No overlap, product = 2 × 2 = 4.

Example 3 — All Words Share Letters

$ Input: words = ["a","aa","aaa","aaaa"]

› Output: 0

💡 Note: All words contain the letter 'a', so no two words can be chosen without sharing common letters.

Constraints

2 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 1000
words[i] consists only of lowercase English letters.

Visualization

Tap to expand

Asked in

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

The key insight is to use bitmasks to represent character sets, enabling O(1) overlap checking via bitwise AND. Best approach uses bit manipulation for ultra-fast comparisons. Time: O(n² + n×m), Space: O(n)

Common Approaches

✓ Bitmask Optimization

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

Convert each word to a bitmask where each bit represents a letter (a-z). Two words share no common letters if their bitmasks have no overlapping bits (bitwise AND equals 0).

Brute Force Character Comparison

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

For each pair of words, iterate through all characters of both words to check if they share any common letters. If no common letters exist, calculate their length product.

Character Set Optimization

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

First convert each word to a character set, then compare sets instead of individual characters. This reduces redundant character comparisons.

Bitmask Optimization — Algorithm Steps

Convert each word to a bitmask
For each pair, check if bitwise AND equals 0
Calculate product for non-overlapping pairs
Track maximum product

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Bitmasks

Each word becomes a binary number

Bitwise AND

Check if masks have overlapping bits

Zero Check

AND = 0 means no common letters

Code -

solution.c — C

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

int solution(char words[][21], int n) {
    int maxProduct = 0;
    
    // Convert each word to a bitmask
    int masks[300];
    for (int i = 0; i < n; i++) {
        int mask = 0;
        for (int j = 0; words[i][j]; j++) {
            mask |= 1 << (words[i][j] - 'a');
        }
        masks[i] = mask;
    }
    
    // Check all pairs using bitwise AND
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if ((masks[i] & masks[j]) == 0) {  // No common letters
                int product = strlen(words[i]) * strlen(words[j]);
                if (product > maxProduct) {
                    maxProduct = product;
                }
            }
        }
    }
    
    return maxProduct;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char words[300][21];
    int n = 0;
    
    // Parse JSON array format: ["word1","word2","word3"]
    char *ptr = line;
    while (*ptr && n < 300) {
        // Find opening quote
        while (*ptr && *ptr != '"') ptr++;
        if (!*ptr) break;
        ptr++; // Skip opening quote
        
        // Extract word until closing quote
        int len = 0;
        while (*ptr && *ptr != '"' && len < 20) {
            words[n][len++] = *ptr++;
        }
        words[n][len] = '\0';
        n++;
        
        // Skip to next potential word
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    int result = solution(words, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² + n×m)

O(n×m) to build bitmasks for n words of average length m, then O(n²) to check all pairs with O(1) comparisons

⚠ Quadratic Growth

Space Complexity

O(n)

Array of n integers to store bitmasks, each taking constant space

⚡ Linearithmic Space

78.0K Views

Medium Frequency

~15 min Avg. Time

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

Maximum Product of Word Lengths - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bitmask Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler