Maximum Score Words Formed by Letters - Practice Coding Problems

Maximum Score Words Formed by Letters - Problem

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

Imagine you're playing a strategic word game where you need to maximize your score by selecting the best combination of words!

You're given:

A list of words that you can potentially form
A collection of available letters (some letters may appear multiple times)
A score array where score[0] represents the points for 'a', score[1] for 'b', and so on

Your goal is to find the maximum possible score by selecting a subset of words that can be formed using the available letters. Remember:

Each word can only be used once
Each letter can only be used once
You don't have to use all available letters
You don't have to form all possible words

The challenge is to find the optimal combination that gives you the highest total score!

Input & Output

example_1.py — Basic Case

$ Input: words = ["dog","cat","dad","good"], letters = ['a','a','c','d','d','d','g','o','o'], score = [1,0,9,5,0,0,3,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0]

› Output: 23

💡 Note: We can form "dad" (d=5, a=1, d=5) and "good" (g=3, o=2, o=2, d=5) for a total score of 11 + 12 = 23. Note that we have enough letters: we have 2 'a's and need 1, we have 3 'd's and need 2, etc.

example_2.py — All Words Case

$ Input: words = ["xxxz","ax","bx","cx"], letters = ['z','a','b','c','x','x','x'], score = [4,4,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2]

› Output: 27

💡 Note: We can form all words: "xxxz" (score: 1+1+1+2=5), "ax" (score: 4+1=5), "bx" (score: 4+1=5), "cx" (score: 4+1=5). We have exactly the right letters: 3 x's for xxxz, 1 x each for ax/bx/cx, and the required a,b,c,z.

example_3.py — No Words Case

$ Input: words = ["leetcode"], letters = ['l','e','t','c','o','d'], score = [0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0]

› Output: 0

💡 Note: We cannot form "leetcode" because we need 2 'e's but only have 1 'e' available. Since we can't form any words, the maximum score is 0.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Count available letters and start with first word

Decision

For each word: can we afford it with current letters?

Spend & Recurse

If yes, spend the letters and explore remaining words

Backtrack

Restore spent letters and try skipping this word

Maximize

Return the maximum score from both choices

Key Takeaway

🎯 Key Insight: Backtracking with pruning allows us to systematically explore all valid word combinations while avoiding impossible branches early, making it much more efficient than brute force enumeration.

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case we still explore all combinations, but pruning makes it much faster in practice

⚠ Quadratic Growth

Space Complexity

O(n + 26)

Recursion stack depth O(n) plus letter frequency array O(26)

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 14
1 ≤ words[i].length ≤ 15
1 ≤ letters.length ≤ 100
letters[i].length == 1
score.length == 26
0 ≤ score[i] ≤ 10⁴
words[i], letters[i] contains only lower case English letters

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 22

The optimal solution uses backtracking to systematically explore all valid combinations of words. For each word, we decide whether to include it by checking if we have enough available letters. The key insight is to use pruning - when we don't have enough letters for a word, we skip it immediately. This approach has O(2^n) time complexity but performs much better than brute force due to early termination.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(2^n)	O(n + 26)	Use backtracking to explore valid combinations efficiently with pruning
Brute Force (Try All Combinations)	O(2^n * m)	O(n)	Generate all possible subsets of words and check which ones are valid

Backtracking (Optimal) — Algorithm Steps

Start with all available letters and empty word selection
For each word, make a decision: include it or skip it
If including: check if we have enough letters for this word
If yes, subtract used letters and recursively explore remaining words
Calculate score for current combination and update maximum
Backtrack by restoring the letter count and try next possibility

Visualization

Tap to expand

Step-by-Step Walkthrough

Decision Point

At each word, decide: include or skip

Feasibility Check

If including, check if enough letters are available

Recursive Exploration

Explore both branches and calculate maximum score

Backtrack

Restore state and try the other option

Code -

solution.c — C

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

int letterCount[26];
char** words;
int* score;
int wordsSize;

int backtrack(int index) {
    if (index == wordsSize) {
        return 0;
    }
    
    // Option 1: Skip current word
    int maxScore = backtrack(index + 1);
    
    // Option 2: Take current word (if possible)
    char* word = words[index];
    int wordScore = 0;
    int wordLetters[26] = {0};
    
    // Count letters in current word and calculate score
    for (int i = 0; word[i]; i++) {
        char c = word[i];
        wordLetters[c - 'a']++;
        wordScore += score[c - 'a'];
    }
    
    // Check if we can form this word
    int canForm = 1;
    for (int i = 0; i < 26; i++) {
        if (letterCount[i] < wordLetters[i]) {
            canForm = 0;
            break;
        }
    }
    
    if (canForm) {
        // Use the letters
        for (int i = 0; i < 26; i++) {
            letterCount[i] -= wordLetters[i];
        }
        
        // Recursively solve for remaining words
        int temp = wordScore + backtrack(index + 1);
        if (temp > maxScore) {
            maxScore = temp;
        }
        
        // Backtrack: restore letters
        for (int i = 0; i < 26; i++) {
            letterCount[i] += wordLetters[i];
        }
    }
    
    return maxScore;
}

int maxScoreWords(char** wordsArray, int wordsArraySize, char* letters, int lettersSize, int* scoreArray, int scoreSize) {
    words = wordsArray;
    wordsSize = wordsArraySize;
    score = scoreArray;
    
    // Initialize letter count
    memset(letterCount, 0, sizeof(letterCount));
    
    // Count available letters
    for (int i = 0; i < lettersSize; i++) {
        letterCount[letters[i] - 'a']++;
    }
    
    return backtrack(0);
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case we still explore all combinations, but pruning makes it much faster in practice

⚠ Quadratic Growth

Space Complexity

O(n + 26)

Recursion stack depth O(n) plus letter frequency array O(26)

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 14
1 ≤ words[i].length ≤ 15
1 ≤ letters.length ≤ 100
letters[i].length == 1
score.length == 26
0 ≤ score[i] ≤ 10⁴
words[i], letters[i] contains only lower case English letters

89.3K Views

Medium Frequency

~25 min Avg. Time

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

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler