Longest Uncommon Subsequence II - Practice Coding Problems

Longest Uncommon Subsequence II - Problem

You are given an array of strings and need to find the longest uncommon subsequence among them. An uncommon subsequence is a string that is a subsequence of exactly one string in the array, but not a subsequence of any other string.

A subsequence is formed by deleting some (possibly zero) characters from a string while maintaining the relative order of remaining characters. For example, "abc" is a subsequence of "aebdc" by removing characters at positions 1 and 3.

Goal: Return the length of the longest uncommon subsequence. If no uncommon subsequence exists, return -1.

Key Insight: Any string that appears only once in the array is automatically an uncommon subsequence (since it's a subsequence of itself but not of any other string)!

Input & Output

example_1.py — Basic Case

$ Input: ["aba", "cdc", "eae"]

› Output: 3

💡 Note: All three strings are unique (appear once), and none can be formed as a subsequence of another. The longest length is 3.

example_2.py — With Duplicates

$ Input: ["aaa", "aaa", "aa"]

› Output: 2

💡 Note: "aaa" appears twice, so it's not uncommon. "aa" appears once and is not a subsequence of any other distinct string, so return 2.

example_3.py — All Same Strings

$ Input: ["aaa", "aaa", "aaa"]

› Output: -1

💡 Note: All strings are identical, so no uncommon subsequence exists.

Constraints

2 ≤ strs.length ≤ 50
1 ≤ strs[i].length ≤ 10
strs[i] consists of lowercase English letters only

Visualization

Tap to expand

Understanding the Visualization

Collect All Signatures

Count how many times each string pattern appears

Find Unique Patterns

Identify strings that appear exactly once

Pick the Longest

Return the length of the longest unique string

Key Takeaway

🎯 Key Insight: A string appearing exactly once is guaranteed to be uncommon - no complex subsequence checking needed!

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a hash table to count string frequencies in O(n×m) time. The key insight is that any string appearing exactly once is automatically an uncommon subsequence, eliminating the need for complex subsequence checking.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subsequences)	O(n * 2^m * n * m)	O(2^m)	Generate all possible subsequences and check if each is uncommon
One-Pass Hash Table (Optimal)	O(n × m)	O(n × m)	Key insight: any string appearing exactly once is automatically an uncommon subsequence
Two-Pass Hash Table	O(n² × m)	O(n)	Count string frequencies, then check unique strings for subsequence relationships

Brute Force (Check All Subsequences) — Algorithm Steps

For each string in the array, generate all possible subsequences
For each subsequence, count how many strings in the array contain it as a subsequence
Keep track of subsequences that appear in exactly one string
Return the length of the longest such subsequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsequences

For each string, create all possible subsequences using bit manipulation

Check Uniqueness

For each subsequence, count in how many original strings it appears

Find Maximum

Among unique subsequences, find the one with maximum length

Code -

solution.c — C

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

int isSubsequence(char* s, char* t) {
    int i = 0, j = 0;
    while (t[j] && s[i]) {
        if (s[i] == t[j]) {
            i++;
        }
        j++;
    }
    return s[i] == '\0';
}

int findLUSlength(char** strs, int strsSize) {
    int maxLength = -1;
    
    // Simple brute force checking each string
    for (int i = 0; i < strsSize; i++) {
        int isUnique = 1;
        for (int j = 0; j < strsSize; j++) {
            if (i != j && strcmp(strs[i], strs[j]) == 0) {
                isUnique = 0;
                break;
            }
        }
        if (isUnique) {
            int len = strlen(strs[i]);
            if (len > maxLength) {
                maxLength = len;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char* strs[] = {"aba", "cdc", "eae"};
    printf("%d\n", findLUSlength(strs, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 2^m * n * m)

For each string (n), generate all subsequences (2^m), check against all strings (n), each check takes O(m)

✓ Linear Growth

Space Complexity

O(2^m)

Store all subsequences of maximum length string

✓ Linear Space

31.2K Views

Medium Frequency

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

Brute Force (Check All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler