Similar String Groups - Practice Coding Problems

Input & Output

example_1.py — Basic Case

$ Input: ["tars", "rats", "arts", "star"]

› Output: 2

💡 Note: "tars", "rats", and "arts" form one group (all connected through similarity), while "star" forms its own group since it's not similar to any other string.

example_2.py — All Similar

$ Input: ["abc", "acb", "bac"]

› Output: 1

💡 Note: All strings can be made similar through at most 2 swaps, so they form one large connected group.

example_3.py — All Identical

$ Input: ["abc", "abc", "abc"]

› Output: 1

💡 Note: All strings are identical, so they form one group (identical strings are considered similar).

Constraints

1 ≤ strs.length ≤ 300
1 ≤ strs[i].length ≤ 1000
All strings have the same length
All strings are anagrams of each other
strs[i] consists of lowercase letters only

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each string is a node, similarity creates edges

Check Similarities

Compare each pair to find all possible connections

Group Components

Use Union-Find to efficiently merge connected groups

Count Groups

Number of distinct roots equals number of groups

Key Takeaway

🎯 Key Insight: Model strings as graph nodes with similarity as edges, then count connected components using Union-Find for optimal efficiency.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

This is a classic graph connectivity problem that can be solved efficiently using Union-Find (Disjoint Set Union). The key insight is to model strings as nodes and similarity relationships as edges, then find the number of connected components. While DFS works with O(n² × m) time complexity, Union-Find provides the same complexity but with better constant factors and cleaner code structure.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Disjoint Set Union)	O(n² × m × α(n))	O(n)	Use Union-Find data structure to efficiently group similar strings

Union-Find (Disjoint Set Union) — Algorithm Steps

Initialize Union-Find with each string as its own group
Check every pair of strings for similarity
If two strings are similar, union their groups
Count the number of distinct groups (roots) in Union-Find

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each string starts as its own group

Check Pairs

Compare each pair of strings for similarity

Union Groups

Merge groups when similar strings are found

Count Components

Final number of distinct groups

Code -

solution.c — C

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

typedef struct {
    int* parent;
    int* rank;
    int components;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->components = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

bool unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x), py = find(uf, y);
    if (px == py) return false;
    
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
    
    uf->components--;
    return true;
}

bool areSimilar(char* s1, char* s2) {
    if (strcmp(s1, s2) == 0) return true;
    
    int diffCount = 0;
    int len = strlen(s1);
    
    for (int i = 0; i < len; i++) {
        if (s1[i] != s2[i]) {
            diffCount++;
            if (diffCount > 2) return false;
        }
    }
    
    return diffCount == 2;
}

int numSimilarGroups(char** strs, int n) {
    UnionFind* uf = createUnionFind(n);
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (areSimilar(strs[i], strs[j])) {
                unionSets(uf, i, j);
            }
        }
    }
    
    int result = uf->components;
    free(uf->parent);
    free(uf->rank);
    free(uf);
    
    return result;
}

int main() {
    char* strs[] = {"tars", "rats", "arts", "star"};
    int n = 4;
    printf("%d\n", numSimilarGroups(strs, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m × α(n))

n² pairs to check, m to compare strings, α(n) for Union-Find operations (nearly constant)

⚠ Quadratic Growth

Space Complexity

O(n)

Union-Find parent and rank arrays

⚡ Linearithmic Space

52.0K Views

Medium Frequency

~25 min Avg. Time

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

Union-Find (Disjoint Set Union) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler