Groups of Strings

Groups of Strings - Problem

You are given a 0-indexed array of strings words. Each string consists of lowercase English letters only. No letter occurs more than once in any string of words.

Two strings s1 and s2 are said to be connected if the set of letters of s2 can be obtained from the set of letters of s1 by any one of the following operations:

Adding exactly one letter to the set of the letters of s1.
Deleting exactly one letter from the set of the letters of s1.
Replacing exactly one letter from the set of the letters of s1 with any letter, including itself.

The array words can be divided into one or more non-intersecting groups. A string belongs to a group if any one of the following is true:

It is connected to at least one other string of the group.
It is the only string present in the group.

Note that the strings in words should be grouped in such a manner that a string belonging to a group cannot be connected to a string present in any other group. It can be proved that such an arrangement is always unique.

Return an array ans of size 2 where:

ans[0] is the maximum number of groups words can be divided into, and
ans[1] is the size of the largest group.

Input & Output

Example 1 — Basic Grouping

$ Input: words = ["a","b","ab","cde"]

› Output: [3,2]

💡 Note: Groups: {"a","ab"} (connected by adding 'b'), {"b"} (isolated), {"cde"} (isolated). Total 3 groups, largest size 2.

Example 2 — Single Large Group

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

› Output: [1,3]

💡 Note: All strings are connected: "a" → "ab" (add 'b'), "ab" → "abc" (add 'c'). One group of size 3.

Example 3 — All Isolated

$ Input: words = ["abc","def","ghi"]

› Output: [3,1]

💡 Note: No connections possible (differ by more than one character). 3 groups, each of size 1.

Constraints

1 ≤ words.length ≤ 2 × 10⁴
1 ≤ words[i].length ≤ 26
words[i] consists of lowercase English letters only
No letter occurs more than once in any words[i]

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8 M Microsoft 6

The key insight is to model this as a graph connectivity problem where strings are connected if they differ by exactly one character operation. The optimal approach uses bit manipulation to represent character sets efficiently and Union-Find to group connected components. Time: O(n² × α(n)), Space: O(n)

Common Approaches

✓ Optimized

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

Bit Manipulation with Union-Find

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

Convert each string to a bitmask where each bit represents a character. Use bit operations to quickly check connections, then use Union-Find to efficiently group connected strings.

Brute Force with Character Comparison

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

For each pair of strings, check if they are connected by comparing their character sets. Build groups by tracking connected components using DFS or Union-Find.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 10000

typedef struct IndexNode {
    int index;
    struct IndexNode* next;
} IndexNode;

typedef struct {
    int* nums;
    int size;
    int capacity;
    IndexNode* indices[MAX_SIZE * 2 + 1];  // Handle negative values
} RandomizedCollection;

int hashIndex(int val) {
    return val + MAX_SIZE;  // Offset for negative values
}

RandomizedCollection* randomizedCollectionCreate() {
    RandomizedCollection* obj = malloc(sizeof(RandomizedCollection));
    obj->capacity = 1000;
    obj->nums = malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    for (int i = 0; i < MAX_SIZE * 2 + 1; i++) {
        obj->indices[i] = NULL;
    }
    srand(time(NULL));
    return obj;
}

bool randomizedCollectionInsert(RandomizedCollection* obj, int val) {
    int hash = hashIndex(val);
    bool wasPresent = obj->indices[hash] != NULL;
    
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        obj->nums = realloc(obj->nums, obj->capacity * sizeof(int));
    }
    
    IndexNode* newNode = malloc(sizeof(IndexNode));
    newNode->index = obj->size;
    newNode->next = obj->indices[hash];
    obj->indices[hash] = newNode;
    
    obj->nums[obj->size++] = val;
    return !wasPresent;
}

bool randomizedCollectionRemove(RandomizedCollection* obj, int val) {
    int hash = hashIndex(val);
    if (obj->indices[hash] == NULL) {
        return false;
    }
    
    IndexNode* node = obj->indices[hash];
    int removeIdx = node->index;
    obj->indices[hash] = node->next;
    free(node);
    
    int lastVal = obj->nums[obj->size - 1];
    obj->nums[removeIdx] = lastVal;
    
    // Update indices for lastVal if not removing last element
    if (removeIdx < obj->size - 1) {
        int lastHash = hashIndex(lastVal);
        IndexNode* current = obj->indices[lastHash];
        while (current != NULL) {
            if (current->index == obj->size - 1) {
                current->index = removeIdx;
                break;
            }
            current = current->next;
        }
    }
    
    obj->size--;
    return true;
}

int randomizedCollectionGetRandom(RandomizedCollection* obj) {
    int randomIndex = rand() % obj->size;
    return obj->nums[randomIndex];
}

void randomizedCollectionFree(RandomizedCollection* obj) {
    for (int i = 0; i < MAX_SIZE * 2 + 1; i++) {
        IndexNode* current = obj->indices[i];
        while (current != NULL) {
            IndexNode* temp = current;
            current = current->next;
            free(temp);
        }
    }
    free(obj->nums);
    free(obj);
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    RandomizedCollection* obj = randomizedCollectionCreate();
    
    // Basic test execution
    randomizedCollectionInsert(obj, 1);
    randomizedCollectionInsert(obj, 1);
    randomizedCollectionInsert(obj, 2);
    
    printf("[null,true,false,true,%d,true,%d]\n", 
           randomizedCollectionGetRandom(obj),
           randomizedCollectionGetRandom(obj));
    
    randomizedCollectionFree(obj);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

234 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