Maximum Length of a Concatenated String with Unique Characters - Problem

You are given an array of strings arr. A string s is formed by the concatenation of a subsequence of arr that has unique characters.

Return the maximum possible length of s.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Concatenation

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

› Output: 4

💡 Note: We can concatenate "un" + "iq" = "uniq" which has 4 unique characters. Other combinations like "unue" have duplicate 'u', so length 4 is maximum.

Example 2 — All Single Characters

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

› Output: 6

💡 Note: We need to find the longest concatenation with all unique characters. Possible combinations include: "cha" (3), "r" (1), "act" (3), "ers" (3), "cha"+"r"="char" (4), "r"+"act"="ract" (4), and "act"+"ers"="acters" (6 unique characters). The maximum length is 6.

Example 3 — No Valid Combination

$ Input: arr = ["aa","bb"]

› Output: 0

💡 Note: Each string itself contains duplicate characters ("aa" has two 'a's, "bb" has two 'b's), so we cannot use any string. Maximum length is 0.

Constraints

1 ≤ arr.length ≤ 16
1 ≤ arr[i].length ≤ 26
arr[i] contains only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

This problem requires finding the longest concatenated string with unique characters from a subsequence of the input array. The key insight is to use backtracking to explore valid combinations while pruning invalid paths early. Best approach is backtracking with bit manipulation for O(1) character overlap detection. Time: O(2^n), Space: O(n).

Common Approaches

✓ Backtracking with Pruning

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

Recursively try including each string in the current concatenation. At each step, check if adding the current string would create duplicates. If so, skip it (prune). Otherwise, recurse with the extended string.

Bit Manipulation with Character Sets

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

Convert each string to a bitmask where each bit represents a character (a=0, b=1, etc.). Use bitwise AND to check for overlapping characters between strings. If (mask1 & mask2) == 0, the strings share no common characters.

Brute Force - Generate All Subsequences

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

Generate all 2^n possible subsequences of the array, concatenate strings in each subsequence, check if result has unique characters, and track maximum length.

Backtracking with Pruning — Algorithm Steps

Start with empty string and index 0
For each remaining string, check if it can be added without creating duplicates
If valid, add string and recurse to next index
Backtrack by removing the string and trying next option
Track maximum length throughout the process

Visualization

Tap to expand

Step-by-Step Walkthrough

Explore

Try adding each string to current combination

Validate

Check if new combination has unique characters

Backtrack

Remove string and try next option if invalid

Code -

solution.c — C

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

int maxLen = 0;

int hasUniqueChars(char* str) {
    int seen[256] = {0};
    for (int i = 0; str[i]; i++) {
        if (seen[(int)str[i]]) return 0;
        seen[(int)str[i]] = 1;
    }
    return 1;
}

void backtrack(char arr[][20], int n, int index, char* current) {
    // Update maximum length
    int len = strlen(current);
    if (len > maxLen) {
        maxLen = len;
    }
    
    // Try including each remaining string
    for (int i = index; i < n; i++) {
        // Skip strings that already have duplicate characters
        if (!hasUniqueChars(arr[i])) {
            continue;
        }
        
        // Try adding this string
        char newString[1000];
        strcpy(newString, current);
        strcat(newString, arr[i]);
        
        // Only recurse if the new string has unique characters
        if (hasUniqueChars(newString)) {
            backtrack(arr, n, i + 1, newString);
        }
    }
}

int solution(char arr[][20], int n) {
    maxLen = 0;
    char current[1000] = "";
    backtrack(arr, n, 0, current);
    return maxLen;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    char arr[16][20];
    int n = 0;
    
    char* token = strtok(line, "[],\"");
    while (token != NULL && n < 16) {
        if (strlen(token) > 0 && strcmp(token, "\n") != 0) {
            strcpy(arr[n++], token);
        }
        token = strtok(NULL, "[],\"");
    }
    
    int result = solution(arr, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × k)

Each string can be included or excluded (2^n combinations), with O(k) work to check uniqueness

⚠ Quadratic Growth

Space Complexity

O(n × k)

Recursion stack depth n and concatenated string of length k

⚡ Linearithmic Space

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

Maximum Length of a Concatenated String with Unique Characters - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Pruning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler