Longest Unequal Adjacent Groups Subsequence I

Longest Unequal Adjacent Groups Subsequence I - Problem

Imagine you have a collection of words and each word belongs to one of two groups (represented as 0 or 1). Your mission is to create the longest possible alternating sequence where no two consecutive words belong to the same group!

🎯 The Challenge: Given a string array words and a binary array groups (both of length n), find the longest subsequence where adjacent elements have different group values. Think of it like creating a pattern that alternates between groups: 0-1-0-1 or 1-0-1-0.

What you need to do:

Select words from the array (maintaining their original order)
Ensure no two consecutive selected words have the same group value
Maximize the length of your selection
Return the actual words in your optimal subsequence

Note: All words are distinct, and if multiple optimal solutions exist, you can return any of them.

Input & Output

example_1.py — Basic Alternating Pattern

$ Input: words = ["e", "a", "b"], groups = [0, 0, 1]

› Output: ["e", "b"]

💡 Note: We start with "e" (group 0), then skip "a" (also group 0 - would create consecutive 0s), and include "b" (group 1). This gives us the alternating pattern 0-1 with maximum length 2.

example_2.py — Perfect Alternation

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

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

💡 Note: The groups already form a perfect alternating pattern 1-0-1-0, so we can include all words in our subsequence for maximum length 4.

example_3.py — Single Group

$ Input: words = ["x", "y", "z"], groups = [1, 1, 1]

› Output: ["x"]

💡 Note: All words belong to the same group (1), so we can only select the first word to avoid consecutive identical groups. The maximum alternating subsequence length is 1.

Visualization

Tap to expand

Understanding the Visualization

Start with First Speaker

Always include the first person - they set the initial team

Look for Alternation

For each next person, check if they're from a different team than the current speaker

Greedy Selection

If they're from a different team, immediately select them - this is always optimal

Continue the Pattern

Repeat until we've considered everyone, building the longest alternating sequence

Key Takeaway

🎯 Key Insight: The greedy approach works because including every alternating element never prevents us from finding a longer sequence later - it's always optimal to take the alternation when available!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the input arrays

✓ Linear Growth

Space Complexity

O(1)

Only storing the result array, no extra data structures needed

✓ Linear Space

Constraints

1 ≤ words.length ≤ 10⁵
1 ≤ words[i].length ≤ 10
groups.length == words.length
groups[i] is either 0 or 1
All strings in words are distinct

Asked in

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

The optimal solution uses a greedy approach with O(n) time complexity. The key insight is that we should include every word whose group differs from the previously selected word's group. This works because including more alternating elements always leads to a longer or equal-length subsequence, making the greedy choice optimal.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n)	O(1)	Scan left to right, always include the next element if it has a different group
Brute Force (Check All Subsequences)	O(n * 2^n)	O(n)	Generate all possible subsequences and find the longest alternating one

Greedy Approach (Optimal) — Algorithm Steps

Start with the first word (it's always included in optimal solution)
Scan through remaining words from left to right
Include a word if its group differs from the last selected word's group
Continue until we've processed all words

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with First Element

Always include the first word as it's optimal to start the sequence

Scan Left to Right

Check each subsequent word to see if it alternates with the last selected

Greedy Selection

Include any word that has a different group than the previously selected word

Code -

solution.c — C

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

char** getLongestAlternatingSubsequence(char** words, int* groups, int n, int* returnSize) {
    if (n == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    char** result = malloc(n * sizeof(char*));
    result[0] = words[0];  // Always include first word
    int lastGroup = groups[0];
    int size = 1;
    
    for (int i = 1; i < n; i++) {
        // Include current word if its group differs from last selected
        if (groups[i] != lastGroup) {
            result[size] = words[i];
            lastGroup = groups[i];
            size++;
        }
    }
    
    *returnSize = size;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the input arrays

✓ Linear Growth

Space Complexity

O(1)

Only storing the result array, no extra data structures needed

✓ Linear Space

Constraints

1 ≤ words.length ≤ 10⁵
1 ≤ words[i].length ≤ 10
groups.length == words.length
groups[i] is either 0 or 1
All strings in words are distinct

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler