Longest Unequal Adjacent Groups Subsequence II

Longest Unequal Adjacent Groups Subsequence II - Problem

Imagine you're a linguist studying word evolution patterns! You have an array of words and a corresponding groups array that categorizes each word.

Your mission is to find the longest subsequence where:

🔄 Adjacent groups alternate: groups[i] != groups[j] for consecutive elements
📏 Words have equal length: Adjacent words in your subsequence must be the same length
🎯 Hamming distance is exactly 1: Adjacent words differ by exactly one character

The hamming distance between two equal-length strings is the number of positions where characters differ. For example, "abc" and "aec" have hamming distance 1.

Return the words corresponding to the longest valid subsequence. If multiple answers exist, return any of them.

Input & Output

example_1.py — Basic alternating groups

$ Input: words = ["bab", "dab", "cab"], groups = [1, 2, 2]

› Output: ["bab", "dab"]

💡 Note: "bab" (group 1) and "dab" (group 2) have different groups, same length (3), and hamming distance 1 (only 'b' vs 'd' differs). "cab" cannot be added because it has the same group as "dab".

example_2.py — Single character differences

$ Input: words = ["a", "b", "c", "d"], groups = [1, 2, 1, 2]

› Output: ["a", "b", "c", "d"]

💡 Note: All adjacent pairs satisfy the conditions: different groups, same length (1), and hamming distance 1. This forms the longest possible alternating sequence.

example_3.py — No valid extensions

$ Input: words = ["abc", "def"], groups = [1, 1]

› Output: ["abc"]

💡 Note: Both words belong to the same group, so no valid alternating subsequence of length > 1 exists. Return any single word.

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 10
words[i] consists of lowercase English letters only
1 ≤ groups[i] ≤ 10⁵
Hamming distance is only defined for equal-length strings

Visualization

Tap to expand

Understanding the Visualization

Identify Candidates

Find all words that can potentially connect (different groups, same length)

Check Mutations

Verify hamming distance is exactly 1 (single character change)

Build Chains

Use DP to find longest valid evolutionary chain

Reconstruct Path

Follow parent pointers to get the actual word sequence

Key Takeaway

🎯 Key Insight: Use dynamic programming to build optimal subsequences by extending previous valid chains, checking three conditions: different groups, equal length, and hamming distance of exactly 1.

Asked in

G Google 42 f Meta 38 a Amazon 25 ⊞ Microsoft 18

This problem requires finding the longest alternating subsequence with specific constraints. The optimal approach uses dynamic programming with O(n²) time complexity, where we build the longest valid sequence ending at each position by checking all previous positions that can extend to it.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n² × m)	O(n)	Build longest sequences ending at each position using memoization
Brute Force (Try All Subsequences)	O(2^n × n × m)	O(n)	Generate all possible subsequences and check validity

Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp array where dp[i] stores the longest subsequence ending at i
For each position i, check all previous positions j
If words[j] can extend to words[i], update dp[i]
Track parent pointers to reconstruct the actual subsequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set dp[i] = 1 for all positions (single word subsequences)

Check Extensions

For each pair (j,i), check if j can extend to i

Update DP

If valid extension, update dp[i] = max(dp[i], dp[j] + 1)

Reconstruct

Follow parent pointers to build final subsequence

Code -

solution.c — C

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

int hammingDistance(char* s1, char* s2) {
    int len1 = strlen(s1), len2 = strlen(s2);
    if (len1 != len2) return INT_MAX;
    
    int diff = 0;
    for (int i = 0; i < len1; i++) {
        if (s1[i] != s2[i]) diff++;
    }
    return diff;
}

char** getWordsInLongestSubsequence(char** words, int wordsSize, int* groups, int* returnSize) {
    if (wordsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    // dp[i] = length of longest subsequence ending at i
    int* dp = (int*)malloc(wordsSize * sizeof(int));
    int* parent = (int*)malloc(wordsSize * sizeof(int));
    
    for (int i = 0; i < wordsSize; i++) {
        dp[i] = 1;
        parent[i] = -1;
    }
    
    for (int i = 1; i < wordsSize; i++) {
        for (int j = 0; j < i; j++) {
            // Check if we can extend from j to i
            if (groups[j] != groups[i] && 
                hammingDistance(words[j], words[i]) == 1) {
                if (dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                    parent[i] = j;
                }
            }
        }
    }
    
    // Find the ending position with maximum length
    int maxLen = 0, endPos = 0;
    for (int i = 0; i < wordsSize; i++) {
        if (dp[i] > maxLen) {
            maxLen = dp[i];
            endPos = i;
        }
    }
    
    // Reconstruct the subsequence
    char** result = (char**)malloc(maxLen * sizeof(char*));
    *returnSize = maxLen;
    
    int curr = endPos;
    for (int i = maxLen - 1; i >= 0; i--) {
        result[i] = words[curr];
        curr = parent[curr];
    }
    
    free(dp);
    free(parent);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² pairs to check, each taking O(m) for hamming distance where m is word length

⚠ Quadratic Growth

Space Complexity

O(n)

DP array and parent pointers for reconstruction

⚡ Linearithmic Space

52.1K Views

Medium-High 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler