Extra Characters in a String

Extra Characters in a String - Problem

You are given a 0-indexed string s and a dictionary of words dictionary. You have to break s into one or more non-overlapping substrings such that each substring is present in dictionary. There may be some extra characters in s which are not present in any of the substrings.

Return the minimum number of extra characters left over if you break up s optimally.

Input & Output

Example 1 — Basic Case

$ Input: s = "leetscode", dictionary = ["leet", "code", "leetcode"]

› Output: 1

💡 Note: We can break s into "leet" + "s" + "code". The character "s" is not in the dictionary, so we have 1 extra character.

Example 2 — Perfect Match

$ Input: s = "sayhelloworld", dictionary = ["hello", "world"]

› Output: 3

💡 Note: We can break s into "say" + "hello" + "world". The substring "say" has 3 extra characters.

Example 3 — No Dictionary Words

$ Input: s = "abc", dictionary = ["def", "ghi"]

› Output: 3

💡 Note: No words from dictionary can be used, so all 3 characters are extra.

Constraints

1 ≤ s.length ≤ 50
1 ≤ dictionary.length ≤ 50
1 ≤ dictionary[i].length ≤ 50
dictionary[i] and s consist of only lowercase English letters
dictionary contains distinct words

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is to use dynamic programming where each position represents the minimum extra characters needed from that point to the end. We can either skip the current character (adding 1 to extra count) or use a dictionary word starting at that position. The optimal approach is bottom-up DP with Time: O(n²×m), Space: O(n).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Create a DP array where dp[i] represents the minimum extra characters needed for substring starting at index i. Fill the array from right to left, using previously computed values to build up the solution.

Brute Force Recursion

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

For each position in the string, recursively try skipping the character (count as extra) or using any dictionary word that starts at that position. Return the minimum extra characters across all possibilities.

Top-Down DP with Memoization

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

Use recursion with memoization to store results of subproblems. For each starting index, we cache the minimum extra characters needed for the remaining string, avoiding redundant calculations.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Create DP array where dp[i] = min extra chars from index i to end
Step 2: Fill array backwards from end of string
Step 3: For each position, try skipping char or using dictionary words

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

dp[i] = min extra chars from index i to end

Fill backwards

For each position, try skip or use dictionary words

Return dp[0]

Answer is minimum extra chars from start

Code -

solution.c — C

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

static char dictionary[1000][51];
static int dictSize = 0;

int isInDict(char* word) {
    for (int i = 0; i < dictSize; i++) {
        if (strcmp(dictionary[i], word) == 0) {
            return 1;
        }
    }
    return 0;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(char* s, char dict[][51], int dictLen) {
    int n = strlen(s);
    dictSize = dictLen;
    
    for (int i = 0; i < dictLen; i++) {
        strcpy(dictionary[i], dict[i]);
    }
    
    static int dp[52]; // Make static to avoid stack issues
    memset(dp, 0, sizeof(dp));
    
    for (int i = n - 1; i >= 0; i--) {
        // Option 1: Skip current character
        dp[i] = dp[i + 1] + 1;
        
        // Option 2: Try dictionary words
        for (int j = i + 1; j <= n; j++) {
            char substring[51];
            strncpy(substring, s + i, j - i);
            substring[j - i] = '\0';
            
            if (isInDict(substring)) {
                dp[i] = min(dp[i], dp[j]);
            }
        }
    }
    
    return dp[0];
}

int main() {
    char sLine[100], dictLine[1000];
    fgets(sLine, sizeof(sLine), stdin);
    fgets(dictLine, sizeof(dictLine), stdin);
    
    // Remove newlines
    sLine[strcspn(sLine, "\n")] = 0;
    dictLine[strcspn(dictLine, "\n")] = 0;
    
    // Parse string (remove quotes)
    char s[51];
    int sLen = strlen(sLine);
    strncpy(s, sLine + 1, sLen - 2);
    s[sLen - 2] = '\0';
    
    // Parse dictionary array
    char dict[100][51];
    int dictLen = 0;
    
    // Remove [ and ]
    char* dictContent = dictLine + 1;
    dictContent[strlen(dictContent) - 1] = '\0';
    
    if (strlen(dictContent) > 0) {
        char* token = strtok(dictContent, ",");
        while (token != NULL && dictLen < 100) {
            // Remove leading/trailing spaces and quotes
            while (*token == ' ') token++;
            char* end = token + strlen(token) - 1;
            while (end > token && *end == ' ') end--;
            *(end + 1) = '\0';
            
            if (*token == '"' && *end == '"') {
                token++;
                *end = '\0';
            }
            
            if (strlen(token) > 0) {
                strcpy(dict[dictLen++], token);
            }
            token = strtok(NULL, ",");
        }
    }
    
    printf("%d\n", solution(s, dict, dictLen));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

For each of n positions, we check all possible substrings (n operations) and verify against dictionary (m average lookups)

⚠ Quadratic Growth

Space Complexity

O(n + m)

DP array of size n plus dictionary storage of size m

⚡ Linearithmic Space

28.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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler