Sentence Similarity II - Practice Coding Problems

Sentence Similarity II - Problem

Array Hash Table String Depth-First Search Breadth-First Search Union Find Medium

Sentence Similarity with Transitive Relations

Given two sentences represented as string arrays and a list of word similarity pairs, determine if the sentences are similar.

Two sentences are considered similar if:
• They have the same length (same number of words)
• Each word at position i in sentence1 is similar to the word at position i in sentence2

The key challenge is that similarity is transitive: if word A is similar to word B, and word B is similar to word C, then A and C are also similar. Every word is always similar to itself.

Example: If we have pairs [("great", "fine"), ("fine", "good")], then "great" and "good" are similar through the transitive relationship.

Your task is to efficiently determine if two sentences can be considered similar given these transitive similarity relationships.

Input & Output

example_1.py — Basic Similarity

$ Input: sentence1 = ["great", "acting", "skills"] sentence2 = ["fine", "drama", "talent"] similarPairs = [["great","fine"],["drama","acting"],["skills","talent"]]

› Output: true

💡 Note: Each word at corresponding positions are directly similar: 'great'↔'fine', 'acting'↔'drama', 'skills'↔'talent'. Since all positions match through direct similarity pairs, the sentences are similar.

example_2.py — Transitive Similarity

$ Input: sentence1 = ["great", "acting"] sentence2 = ["good", "drama"] similarPairs = [["great","fine"],["fine","good"],["acting","drama"]]

› Output: true

💡 Note: Position 0: 'great' and 'good' are similar through transitive relationship: great→fine→good. Position 1: 'acting' and 'drama' are directly similar. Both positions satisfy similarity requirements.

example_3.py — Different Lengths

$ Input: sentence1 = ["I", "love", "coding"] sentence2 = ["I", "love"] similarPairs = []

› Output: false

💡 Note: The sentences have different lengths (3 vs 2 words), so they cannot be similar regardless of similarity pairs. This is caught immediately without processing any pairs.

Visualization

Tap to expand

Understanding the Visualization

Build Social Circles

Start with everyone as individual nodes, then merge friends into communities

Process Friendships

For each friendship pair, union their communities using efficient path compression

Query Relationships

To check if two people are connected, verify they belong to the same community

Key Takeaway

🎯 Key Insight: Union-Find transforms the complex problem of checking transitive relationships into simple community membership queries, achieving near-constant time complexity for each comparison.

Time & Space Complexity

Time Complexity

⏱️

O(P × α(W) + N × α(W))

P union operations for similarity pairs plus N find operations for sentence comparison, where α is inverse Ackermann

✓ Linear Growth

Space Complexity

O(W)

Union-Find structure storing parent and rank for each unique word W

✓ Linear Space

Constraints

1 ≤ sentence1.length, sentence2.length ≤ 1000
1 ≤ sentence1[i].length, sentence2[i].length ≤ 20
sentence1[i] and sentence2[i] consist of lowercase English letters
0 ≤ similarPairs.length ≤ 2000
similarPairs[i].length == 2
1 ≤ similarPairs[i][0].length, similarPairs[i][1].length ≤ 20
similarPairs[i][0] and similarPairs[i][1] consist of lowercase English letters
Key insight: Similarity relation is transitive and reflexive

Asked in

G Google 42 f Facebook 38 a Amazon 31 ⊞ Microsoft 25

The optimal solution uses Union-Find (Disjoint Set Union) to efficiently handle transitive similarity relationships. First, we build connected components by unioning all similar word pairs. Then, for each sentence position, we check if the corresponding words belong to the same component in O(α(n)) time. This approach excels when dealing with multiple similarity queries as it preprocesses the transitive closure once and answers queries nearly instantly.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(P × α(W) + N × α(W))	O(W)	Use Union-Find to group similar words, then check if word pairs belong to same component
Brute Force DFS for Each Pair	O(n × (V + E))	O(V + E)	For each word pair, run DFS to check if they're connected through similarity chains

Union-Find (Optimal) — Algorithm Steps

Check if sentences have equal length
Initialize Union-Find structure
Union all similar word pairs to build components
For each position, check if words belong to same component

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Each word is its own component initially

Union Pairs

Merge components for each similarity pair

Query

Check if two words belong to same component

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 20

typedef struct {
    char words[MAX_WORDS][MAX_WORD_LEN];
    int parent[MAX_WORDS];
    int rank[MAX_WORDS];
    int count;
} UnionFind;

int find_word_index(UnionFind* uf, const char* word) {
    for (int i = 0; i < uf->count; i++) {
        if (strcmp(uf->words[i], word) == 0) {
            return i;
        }
    }
    strcpy(uf->words[uf->count], word);
    uf->parent[uf->count] = uf->count;
    uf->rank[uf->count] = 0;
    return uf->count++;
}

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

void union_sets(UnionFind* uf, int x, int y) {
    int rootX = find_root(uf, x);
    int rootY = find_root(uf, y);
    if (rootX == rootY) return;
    
    // Union by rank
    if (uf->rank[rootX] < uf->rank[rootY]) {
        uf->parent[rootX] = rootY;
    } else if (uf->rank[rootX] > uf->rank[rootY]) {
        uf->parent[rootY] = rootX;
    } else {
        uf->parent[rootY] = rootX;
        uf->rank[rootX]++;
    }
}

bool connected(UnionFind* uf, const char* word1, const char* word2) {
    int idx1 = find_word_index(uf, word1);
    int idx2 = find_word_index(uf, word2);
    return find_root(uf, idx1) == find_root(uf, idx2);
}

bool areSentencesSimilarTwo(char** sentence1, int sentence1Size, char** sentence2, int sentence2Size, char*** similarPairs, int similarPairsSize) {
    if (sentence1Size != sentence2Size) {
        return false;
    }
    
    UnionFind uf = {0};
    
    // Build Union-Find structure
    for (int i = 0; i < similarPairsSize; i++) {
        int idx1 = find_word_index(&uf, similarPairs[i][0]);
        int idx2 = find_word_index(&uf, similarPairs[i][1]);
        union_sets(&uf, idx1, idx2);
    }
    
    // Check each position
    for (int i = 0; i < sentence1Size; i++) {
        if (strcmp(sentence1[i], sentence2[i]) != 0 && !connected(&uf, sentence1[i], sentence2[i])) {
            return false;
        }
    }
    
    return true;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(P × α(W) + N × α(W))

P union operations for similarity pairs plus N find operations for sentence comparison, where α is inverse Ackermann

✓ Linear Growth

Space Complexity

O(W)

Union-Find structure storing parent and rank for each unique word W

✓ Linear Space

Constraints

1 ≤ sentence1.length, sentence2.length ≤ 1000
1 ≤ sentence1[i].length, sentence2[i].length ≤ 20
sentence1[i] and sentence2[i] consist of lowercase English letters
0 ≤ similarPairs.length ≤ 2000
similarPairs[i].length == 2
1 ≤ similarPairs[i][0].length, similarPairs[i][1].length ≤ 20
similarPairs[i][0] and similarPairs[i][1] consist of lowercase English letters
Key insight: Similarity relation is transitive and reflexive

28.6K Views

Medium-High Frequency

~22 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

Union-Find (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler