Longest Unequal Adjacent Groups Subsequence II

Longest Unequal Adjacent Groups Subsequence II - Problem

You are given a string array words and an array groups, both arrays having length n.

The hamming distance between two strings of equal length is the number of positions at which the corresponding characters are different.

You need to select the longest subsequence from an array of indices [0, 1, ..., n - 1], such that for the subsequence denoted as [i₀, i₁, ..., iₖ₋₁] having length k, the following holds:

For adjacent indices in the subsequence, their corresponding groups are unequal, i.e., groups[iⱼ] != groups[iⱼ₊₁], for each j where 0 ≤ j + 1 < k.
words[iⱼ] and words[iⱼ₊₁] are equal in length, and the hamming distance between them is 1, where 0 ≤ j + 1 < k, for all indices in the subsequence.

Return a string array containing the words corresponding to the indices (in order) in the selected subsequence. If there are multiple answers, return any of them.

Note: strings in words may be unequal in length.

Input & Output

Example 1 — Basic Valid Chain

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

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

💡 Note: Chain a→b→c: groups [1,0,1] are alternating, hamming distances are 1 (a≠b at 1 position, b≠c at 1 position). Length = 3.

Example 2 — Different Length Words

$ Input: words = ["a","ab","abc"], groups = [0,0,1]

› Output: ["ab"]

💡 Note: Words have different lengths so cannot form valid chain with hamming distance constraint. Best subsequence has length 1.

Example 3 — Same Groups

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

› Output: ["abc"]

💡 Note: Both words have same group (0), so cannot form chain. Maximum subsequence length is 1.

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 10
groups.length == words.length
0 ≤ groups[i] ≤ 1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use dynamic programming to track the longest valid subsequence ending at each position. For each word, try extending all previous valid chains that satisfy both the group constraint (different groups) and hamming distance constraint (same length, distance = 1). Best approach is DP with time O(n² × m) and space O(n).

Common Approaches

✓ Math

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

Brute Force - Try All Subsequences

⏱️ Time: O(2ⁿ × n × m) Space: O(n)

Generate all 2^n possible subsequences, then for each subsequence check if it satisfies both the group constraint (adjacent elements have different groups) and hamming distance constraint (adjacent words have same length and hamming distance of 1).

Dynamic Programming

⏱️ Time: O(n² × m) Space: O(n)

Use dynamic programming where dp[i] represents the longest valid subsequence ending at position i. For each position, try extending all previous valid subsequences that satisfy the constraints.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool solution(int** mat, int m, int n, int k) {
    return k % n == 0;
}

int main() {
    // Simple parsing for small test cases
    int m = 2, n = 2;
    int** mat = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        mat[i] = malloc(n * sizeof(int));
    }
    
    // Read matrix values (simplified)
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse [[1,2],[3,4]] format (simplified)
    mat[0][0] = 1; mat[0][1] = 2;
    mat[1][0] = 3; mat[1][1] = 4;
    
    int k;
    scanf("%d", &k);
    
    bool result = solution(mat, m, n, k);
    printf(result ? "true\n" : "false\n");
    
    for (int i = 0; i < m; i++) {
        free(mat[i]);
    }
    free(mat);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

485 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