Decremental String Concatenation - Practice Coding Problems

Decremental String Concatenation - Problem

You're given an array of n strings and need to strategically combine them to create the shortest possible final string.

The key insight is in how strings are joined: when concatenating two strings x and y, if the last character of x matches the first character of y, one of the duplicate characters gets removed! This creates opportunities for optimization.

Join Operation Rules:

join("ab", "ba") = "aba" (duplicate 'b' removed)
join("ab", "cde") = "abcde" (no duplicates)

You must perform exactly n-1 join operations, starting with the first string. At each step, you can choose to either:

Append the next word to your current result
Prepend the next word to your current result

Your goal: Find the order that minimizes the final string length by maximizing character deletions.

Input & Output

example_1.py — Basic joining

$ Input: words = ["aa", "ab", "bc"]

› Output: 4

💡 Note: Start with "aa". We can append "ab" to get "aab" (length 3), then append "bc" to get "aabc" (length 4). The 'b' characters merge when joining "ab" and "bc".

example_2.py — Optimal ordering

$ Input: words = ["ab", "b"]

› Output: 2

💡 Note: Start with "ab". Append "b" to get "ab" + "b" = "ab" (the duplicate 'b' is removed). Final length is 2.

example_3.py — No merging possible

$ Input: words = ["aaa", "c", "aba"]

› Output: 6

💡 Note: No characters can be merged regardless of order, so we get the sum of all lengths: 3 + 1 + 2 = 6.

Constraints

1 ≤ words.length ≤ 12
1 ≤ words[i].length ≤ 20
words[i] consists of lowercase English letters only
Small input size makes exponential solutions viable

Visualization

Tap to expand

Understanding the Visualization

Start with first word

Begin building our chain with words[0]

Consider merge opportunities

For each new word, check if last char of chain matches first char of word

Try both directions

Test both appending and prepending the new word

Choose optimal path

Select the direction that maximizes character savings

Key Takeaway

🎯 Key Insight: We only need to track the first and last characters of our current result string along with which words we've used, enabling efficient memoization without storing full strings.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

This is a dynamic programming with memoization problem. The key insight is that we only need to track the first and last characters of our current string along with which words we've used, rather than storing entire strings. The optimal approach uses bitmasks to represent used words and caches results based on (mask, first_char, last_char) states, achieving O(n × 2^n) complexity which is acceptable given the constraint that n ≤ 12.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n × 2^n)	O(2^n)	Cache results based on current string's first and last characters to avoid recomputation
Brute Force (Try All Combinations)	O(2^n × L)	O(n × L)	Generate all possible ways to join strings and find the minimum length

Dynamic Programming with Memoization — Algorithm Steps

Create a memoization cache keyed by (used_mask, first_char, last_char)
For each state, try adding each unused word in both directions
Calculate the length gained by each join operation
Return cached result if state was seen before
Store and return minimum length for current state

Visualization

Tap to expand

Step-by-Step Walkthrough

Define state

State = (used_words_mask, first_char, last_char)

Check cache

Look up current state in memoization table

Compute if new

Try all unused words in both directions

Cache result

Store minimum length for this state

Code -

solution.c — C

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

#define MAX_WORDS 20
#define MAX_LEN 50

struct State {
    int mask;
    char first, last;
    int result;
    struct State* next;
};

struct State* memo[10007];

int hash(int mask, char first, char last) {
    return (mask * 256 + first) * 256 + last;
}

int findMemo(int mask, char first, char last) {
    int h = hash(mask, first, last) % 10007;
    struct State* curr = memo[h];
    while (curr) {
        if (curr->mask == mask && curr->first == first && curr->last == last) {
            return curr->result;
        }
        curr = curr->next;
    }
    return -1;
}

void storeMemo(int mask, char first, char last, int result) {
    int h = hash(mask, first, last) % 10007;
    struct State* newState = malloc(sizeof(struct State));
    newState->mask = mask;
    newState->first = first;
    newState->last = last;
    newState->result = result;
    newState->next = memo[h];
    memo[h] = newState;
}

int dp(int mask, char firstChar, char lastChar, char words[][MAX_LEN], int n) {
    int cached = findMemo(mask, firstChar, lastChar);
    if (cached != -1) return cached;
    
    int usedCount = __builtin_popcount(mask);
    if (usedCount == n) {
        return 0;
    }
    
    int minLength = INT_MAX;
    
    for (int i = 0; i < n; i++) {
        if (mask & (1 << i)) continue;
        
        int wordLen = strlen(words[i]);
        int newMask = mask | (1 << i);
        
        if (usedCount == 0) {
            int result = dp(newMask, words[i][0], words[i][wordLen-1], words, n) + wordLen;
            if (result < minLength) minLength = result;
        } else {
            // Try appending
            int appendLen = wordLen - (lastChar == words[i][0] ? 1 : 0);
            int appendResult = dp(newMask, firstChar, words[i][wordLen-1], words, n) + appendLen;
            if (appendResult < minLength) minLength = appendResult;
            
            // Try prepending
            int prependLen = wordLen - (words[i][wordLen-1] == firstChar ? 1 : 0);
            int prependResult = dp(newMask, words[i][0], lastChar, words, n) + prependLen;
            if (prependResult < minLength) minLength = prependResult;
        }
    }
    
    storeMemo(mask, firstChar, lastChar, minLength);
    return minLength;
}

int minimizeConcatenatedLength(char words[][MAX_LEN], int n) {
    memset(memo, 0, sizeof(memo));
    return dp(0, ' ', ' ', words, n);
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

n words to try for each of 2^n possible subsets of used words

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores results for each subset of words

⚠ Quadratic Space

18.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Dynamic Programming with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler