Frequencies of Shortest Supersequences

Frequencies of Shortest Supersequences - Problem

Array String Bit Manipulation Graph Topological Sort Enumeration Hard

Find All Shortest Common Supersequences

You are given an array of strings words. Your task is to find all shortest common supersequences (SCS) of these words that are not permutations of each other.

A shortest common supersequence is a string of minimum length that contains each string in words as a subsequence. Multiple different SCS may exist for the same input.

Return a 2D array of integers freqs where each freqs[i] is an array of size 26, representing the frequency of each letter (a-z) in a unique SCS. You may return the frequency arrays in any order.

Example: For words = ["abc", "ac"], one SCS could be "abc" (frequencies: [1,1,1,0,0,...,0]), but there might be other non-permutation SCS like "abcc" if that's also minimal length.

Input & Output

example_1.py — Basic Case

$ Input: words = ["abc", "ac"]

› Output: [[1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]

💡 Note: The shortest common supersequence is "abc" with length 3. It contains both "abc" and "ac" as subsequences. The frequency array shows 1 occurrence each of 'a', 'b', and 'c'.

example_2.py — Multiple Solutions

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

› Output: [[2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]

💡 Note: Two different shortest supersequences exist: "aba" and "bab". Both have length 3 but different character frequencies, so both are included in the result.

example_3.py — Single Word

$ Input: words = ["abc"]

› Output: [[1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]

💡 Note: When there's only one word, the shortest common supersequence is the word itself. The frequency array represents the character counts in "abc".

Constraints

1 ≤ words.length ≤ 8
1 ≤ words[i].length ≤ 8
words[i] consists of lowercase English letters only
All strings in words are unique
The total number of characters across all words ≤ 50

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

This problem requires finding all shortest common supersequences that are not permutations of each other. The optimal approach uses dynamic programming to first determine the minimum length, then backtracking to enumerate all possible constructions. Key insight: merge strings optimally while preserving subsequence relationships for all input words.

Common Approaches

✓ Bit Manipulation

⏱️ Time: N/A Space: N/A

Brute Force (Generate All Sequences)

⏱️ Time: O(26^L * n * m) Space: O(26^L)

Generate all possible sequences of increasing length until we find supersequences that contain all input words as subsequences. This approach systematically explores all possibilities.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>

// Assume commonBits API is available
int commonBits(int num) {
    // This would be provided by the system
    return 0;
}

int solution() {
    int original = 0;
    
    for (int bitPos = 0; bitPos < 30; bitPos++) {
        int testVal = 1 << bitPos;
        int commonCount = commonBits(testVal);
        int commonCount2 = commonBits(testVal);
        
        if (commonCount != commonCount2) {
            original |= testVal;
        }
    }
    
    return original;
}

int main() {
    int result = solution();
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

15.8K Views

Medium Frequency

~35 min Avg. Time

420 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