Number of Ways to Form a Target String Given a Dictionary

Number of Ways to Form a Target String Given a Dictionary - Problem

Number of Ways to Form a Target String Given a Dictionary

You are given a list of strings words of the same length and a string target. Your mission is to count how many different ways you can form the target string using characters from the dictionary words.

Rules:
1. Build target from left to right
2. To form the ith character of target, you can pick the kth character from any word in words
3. Key constraint: Once you use position k from any word, all positions ≤ k become unusable for future characters
4. You can use multiple characters from the same word (as long as positions increase)

Goal: Return the number of ways to form target modulo 10⁹ + 7.

Example: If words = ["acca", "bbbb", "caca"] and target = "aba", you need to find all ways to pick characters at increasing positions that spell "aba".

Input & Output

example_1.py — Basic case

$ Input: words = ["acca", "bbbb", "caca"], target = "aba"

› Output: 6

💡 Note: There are 6 ways to form "aba": Use 'a' from pos 0, 'b' from pos 1, 'a' from pos 2. Different combinations of words give us: (word0[0], word1[1], word0[2]), (word0[0], word1[1], word2[2]), (word0[0], word1[2], word0[3]), (word0[0], word1[2], word2[3]), (word2[0], word1[1], word0[2]), (word2[0], word1[1], word2[2])

example_2.py — No valid ways

$ Input: words = ["abcd"], target = "xyz"

› Output: 0

💡 Note: Cannot form "xyz" because 'x', 'y', 'z' don't exist in any of the words.

example_3.py — Multiple same characters

$ Input: words = ["abab", "baba"], target = "ab"

› Output: 7

💡 Note: Ways to form "ab": position combinations (0,1), (0,2), (0,3), (2,3) from different word selections give us 7 total ways when accounting for which specific words we choose from.

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 1000
All strings in words have the same length
1 ≤ target.length ≤ 1000
words[i] and target contain only lowercase English letters

Asked in

The optimal solution uses bottom-up dynamic programming with character frequency preprocessing. Key insights: (1) Precompute character frequencies at each position across all words for O(1) lookup, (2) Use DP state dp[i][j] representing ways to form target[0:i] using first j positions, (3) Two choices at each position: skip it or use it if it contains the needed character. Time complexity: O(n×m), space: O(n×m) where n=target length, m=word length.

Common Approaches

Approach	Time	Space	Notes
✓ Bottom-Up Dynamic Programming (Optimal)	O(n * m + w * m)	O(n * m)	Iterative DP with character frequency optimization
Recursive Brute Force	O(m^n * w)	O(n)	Try all possible ways to pick characters recursively
Memoized Dynamic Programming	O(n * m)	O(n * m)	Add memoization to avoid recalculating the same subproblems

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Precompute character frequency at each position across all words
Create DP table where dp[i][j] = ways to form target[0:i] using positions [0:j]
For each position j, we can either skip it or use it (if it has target[i-1])
If we use position j: dp[i][j] = dp[i][j-1] + freq[j-1][target[i-1]] × dp[i-1][j-1]
If we skip: dp[i][j] = dp[i][j-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base case: dp[0][j] = 1 for all j

Fill Row

For each target character, fill the entire row

Two Choices

Skip position or use it (if character matches)

Final Answer

dp[n][m] contains the answer

Code -

solution.c — C

#define MOD 1000000007

int numWays(char** words, int wordsSize, char* target) {
    int m = strlen(words[0]);
    int n = strlen(target);
    
    // Precompute frequencies
    int freq[m][26];
    memset(freq, 0, sizeof(freq));
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; j < m; j++) {
            freq[j][words[i][j] - 'a']++;
        }
    }
    
    // DP table
    long long dp[n+1][m+1];
    memset(dp, 0, sizeof(dp));
    
    // Base case
    for (int j = 0; j <= m; j++) {
        dp[0][j] = 1;
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            // Don't use position j-1
            dp[i][j] = dp[i][j-1];
            
            // Use position j-1
            int charIdx = target[i-1] - 'a';
            if (freq[j-1][charIdx] > 0) {
                dp[i][j] = (dp[i][j] + (long long)freq[j-1][charIdx] * dp[i-1][j-1]) % MOD;
            }
        }
    }
    
    return (int)dp[n][m];
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m + w * m)

O(w * m) to precompute frequencies + O(n * m) for DP table. w=words count, n=target length, m=word length

✓ Linear Growth

Space Complexity

O(n * m)

DP table size, can be optimized to O(m) using rolling array

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 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