Groups of Special-Equivalent Strings

Groups of Special-Equivalent Strings - Problem

You are given an array of strings words where all strings have the same length.

In one move, you can swap any two even indexed characters or any two odd indexed characters of a string words[i].

Two strings words[i] and words[j] are special-equivalent if after any number of moves, words[i] == words[j].

For example, words[i] = "zzxy" and words[j] = "xyzz" are special-equivalent because we may make the moves "zzxy" → "xzzy" → "xyzz".

A group of special-equivalent strings from words is a non-empty subset where:

Every pair of strings in the group are special-equivalent
The group is the largest size possible (no string outside the group is special-equivalent to every string in the group)

Return the number of groups of special-equivalent strings from words.

Input & Output

Example 1 — Basic Grouping

$ Input: words = ["abc","acb","bac","bca","cab","cba"]

› Output: 3

💡 Note: Group 1: ["abc","bac"] (even: "ac", odd: "b"), Group 2: ["acb","bca","cab","cba"] (even: "ac"/"bc"/"cb", odd: "cb"/"a"/"a"), Group 3: singles. After proper analysis: 3 distinct signatures.

Example 2 — All Same Group

$ Input: words = ["a"]

› Output: 1

💡 Note: Single string forms one group.

Example 3 — No Equivalents

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

› Output: 4

💡 Note: "aa" (even:"a", odd:"a"), "bb" (even:"b", odd:"b"), "ab" (even:"a", odd:"b"), "ba" (even:"b", odd:"a") - all different signatures.

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 20
words[i] consists of lowercase English letters
All the strings are of the same length

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that two strings are special-equivalent if their even-positioned and odd-positioned characters can be rearranged to match. Best approach is hash map with signatures - create a unique signature by sorting even and odd characters separately. Time: O(n × m log m), Space: O(n × m)

Common Approaches

✓ Brute Force Comparison

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

For each pair of strings, check if they can be made equal by swapping characters at even positions with even positions and odd positions with odd positions. This requires checking if the sorted even characters and sorted odd characters match.

Hash Map with Signature

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

For each string, create a signature by sorting the even-positioned and odd-positioned characters separately. Strings with the same signature belong to the same group. Use a hash map to count unique signatures.

Brute Force Comparison — Algorithm Steps

For each pair of strings
Extract even and odd positioned characters
Sort both groups and compare
Count unique equivalence classes

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Characters

Separate even and odd positioned characters

Sort & Compare

Sort both groups and check if they match

Group Formation

Mark equivalent strings as visited

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(char*)a - *(char*)b);
}

bool areEquivalent(const char* s1, const char* s2) {
    int len = strlen(s1);
    if (len != strlen(s2)) return false;
    
    char even1[51], odd1[51], even2[51], odd2[51];
    int evenIdx1 = 0, oddIdx1 = 0, evenIdx2 = 0, oddIdx2 = 0;
    
    for (int i = 0; i < len; i++) {
        if (i % 2 == 0) {
            even1[evenIdx1++] = s1[i];
            even2[evenIdx2++] = s2[i];
        } else {
            odd1[oddIdx1++] = s1[i];
            odd2[oddIdx2++] = s2[i];
        }
    }
    
    even1[evenIdx1] = '\0';
    odd1[oddIdx1] = '\0';
    even2[evenIdx2] = '\0';
    odd2[oddIdx2] = '\0';
    
    qsort(even1, evenIdx1, sizeof(char), compare);
    qsort(odd1, oddIdx1, sizeof(char), compare);
    qsort(even2, evenIdx2, sizeof(char), compare);
    qsort(odd2, oddIdx2, sizeof(char), compare);
    
    return strcmp(even1, even2) == 0 && strcmp(odd1, odd2) == 0;
}

int solution(char words[][51], int n) {
    bool visited[1000] = {false};
    int groups = 0;
    
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            groups++;
            visited[i] = true;
            for (int j = i + 1; j < n; j++) {
                if (!visited[j] && areEquivalent(words[i], words[j])) {
                    visited[j] = true;
                }
            }
        }
    }
    
    return groups;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char words[1000][51];
    int count = 0;
    
    char* ptr = strchr(line, '[') + 1;
    char* end = strrchr(line, ']');
    *end = '\0';
    
    char* token = strtok(ptr, ",");
    while (token != NULL) {
        while (*token == ' ' || *token == '"') token++;
        char* wordEnd = token + strlen(token) - 1;
        while (*wordEnd == ' ' || *wordEnd == '"') *wordEnd-- = '\0';
        strcpy(words[count++], token);
        token = strtok(NULL, ",");
    }
    
    int result = solution(words, count);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m log m)

Compare n² pairs, each comparison sorts characters of length m

⚠ Quadratic Growth

Space Complexity

O(m)

Temporary arrays to store even and odd characters

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

856 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 Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler