Maximum Length of a Concatenated String with Unique Characters

Maximum Length of a Concatenated String with Unique Characters - Problem

You are given an array of strings arr. Your task is to find the maximum possible length of a string formed by concatenating a subsequence of these strings, where the resulting string contains only unique characters.

A subsequence is derived from the original array by selecting some (or none) of the strings while maintaining their relative order. For example, from ["a", "b", "c"], valid subsequences include ["a", "c"], ["b"], or [].

Key constraints:

The concatenated result must have all unique characters
You want to maximize the length of this result
Individual strings in the input may already contain duplicate characters (these should be ignored)

Example: Given ["un", "iq", "ue"], you can form "unique" by concatenating all three strings, resulting in length 6.

Input & Output

example_1.py — Basic Case

$ Input: ["un", "iq", "ue"]

› Output: 6

💡 Note: We can concatenate all three strings to form "unique" which has 6 unique characters. This is the maximum possible length.

example_2.py — With Invalid Strings

$ Input: ["cha", "r", "act", "ers"]

› Output: 6

💡 Note: The best combination is "chaers" (using "cha", "r", and "ers") which has 6 unique characters. We can't include "act" because it would create duplicates with "cha".

example_3.py — Single Character Strings

$ Input: ["a", "b", "c", "d", "e", "f"]

› Output: 6

💡 Note: We can concatenate all strings to get "abcdef" with 6 unique characters.

Visualization

Tap to expand

Understanding the Visualization

Filter Invalid Candidates

Remove any strings that already have duplicate characters - these can never contribute to a valid solution

Use Smart Exploration

Try adding each string to your current combination, but check for conflicts first

Early Conflict Detection

If adding a string would create duplicates, skip it immediately and try the next option

Track Best Solution

Keep updating your best result as you find longer valid combinations

Key Takeaway

🎯 Key Insight: Backtracking with early conflict detection allows us to efficiently explore only valid combinations, avoiding the exponential overhead of checking invalid paths. Using bit manipulation for character sets makes conflict detection O(1).

Time & Space Complexity

Time Complexity

⏱️

O(2^n * m)

2^n subsequences to check, each taking O(m) time to validate where m is average string length

⚠ Quadratic Growth

Space Complexity

O(m)

Space for concatenated strings and character frequency checking

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 16
1 ≤ arr[i].length ≤ 26
arr[i] contains only lowercase English letters
The maximum possible length will not exceed 26 (since there are only 26 unique lowercase letters)

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses backtracking with early pruning to explore all valid combinations efficiently. By filtering invalid strings upfront and checking for character conflicts before recursing, we avoid generating invalid combinations entirely. The key insight is representing character sets as bitmasks for O(1) conflict detection, making this approach significantly faster than brute force while maintaining the same theoretical complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Subsequences	O(2^n * m)	O(m)	Generate all possible subsequences and check each for uniqueness
Backtracking with Pruning	O(2^n)	O(n)	Use backtracking to explore valid combinations, pruning early when conflicts detected

Generate All Subsequences — Algorithm Steps

Generate all possible subsequences of the input array
For each subsequence, concatenate all strings
Check if the concatenated string has all unique characters
Track the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequences

Create all 2^n possible combinations

Concatenate Strings

Join selected strings together

Check Uniqueness

Verify all characters are unique

Track Maximum

Update maximum length if valid

Code -

solution.c — C

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

bool hasUniqueChars(char* s) {
    bool seen[26] = {false};
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        int index = s[i] - 'a';
        if (seen[index]) {
            return false;
        }
        seen[index] = true;
    }
    return true;
}

int maxLength(char** arr, int arrSize) {
    int maxLen = 0;
    char concatenated[1000];
    
    // Generate all 2^n subsequences
    for (int mask = 0; mask < (1 << arrSize); mask++) {
        concatenated[0] = '\0';
        
        for (int i = 0; i < arrSize; i++) {
            if (mask & (1 << i)) {
                strcat(concatenated, arr[i]);
            }
        }
        
        if (hasUniqueChars(concatenated)) {
            int len = strlen(concatenated);
            if (len > maxLen) {
                maxLen = len;
            }
        }
    }
    
    return maxLen;
}

int main() {
    char* arr[] = {"un", "iq", "ue"};
    printf("%d\n", maxLength(arr, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * m)

2^n subsequences to check, each taking O(m) time to validate where m is average string length

⚠ Quadratic Growth

Space Complexity

O(m)

Space for concatenated strings and character frequency checking

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 16
1 ≤ arr[i].length ≤ 26
arr[i] contains only lowercase English letters
The maximum possible length will not exceed 26 (since there are only 26 unique lowercase letters)

52.3K Views

Medium-High Frequency

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

Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler