Sentence Similarity II

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.

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

Visualization

Tap to expand

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

✓ Brute Force DFS for Each Pair

⏱️ Time: O(n × (V + E)) Space: O(V + E)

Build a graph from similarity pairs and perform DFS for each position to check if words are connected. This approach rebuilds the connection search for every word pair comparison.

Union-Find (Optimal)

⏱️ Time: O(P × α(W) + N × α(W)) Space: O(W)

Build connected components using Union-Find data structure during initialization. Each similarity pair unions two words into the same component. Then checking similarity becomes an O(α(n)) operation where α is the inverse Ackermann function.

Brute Force DFS for Each Pair — Algorithm Steps

Check if sentences have equal length
Build adjacency list from similarity pairs
For each position i, run DFS from sentence1[i] to find sentence2[i]
If any position fails, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from similarity pairs

Compare Position 0

Run DFS to check if words at position 0 are connected

Repeat for All

Continue DFS search for each remaining position

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 25
#define MAX_PAIRS 2000

static char graph_vertices[MAX_WORDS][MAX_WORD_LEN];
static int graph_adj[MAX_WORDS][MAX_WORDS];
static int graph_adj_count[MAX_WORDS];
static int vertex_count = 0;
static bool visited[MAX_WORDS];

int find_vertex(const char* word) {
    for (int i = 0; i < vertex_count; i++) {
        if (strcmp(graph_vertices[i], word) == 0) {
            return i;
        }
    }
    strcpy(graph_vertices[vertex_count], word);
    graph_adj_count[vertex_count] = 0;
    return vertex_count++;
}

int lookup_vertex(const char* word) {
    for (int i = 0; i < vertex_count; i++) {
        if (strcmp(graph_vertices[i], word) == 0) {
            return i;
        }
    }
    return -1;
}

bool dfs(int start, int target) {
    if (start == target) {
        return true;
    }
    visited[start] = true;
    
    for (int i = 0; i < graph_adj_count[start]; i++) {
        int neighbor = graph_adj[start][i];
        if (!visited[neighbor]) {
            if (dfs(neighbor, target)) {
                return true;
            }
        }
    }
    return false;
}

void parse_pairs(const char* pairsStr, char pairs[][2][MAX_WORD_LEN], int* pairCount) {
    *pairCount = 0;
    
    if (strcmp(pairsStr, "[]") == 0) {
        return;
    }
    
    int len = strlen(pairsStr);
    int i = 0;
    
    // Find first '['
    while (i < len && pairsStr[i] != '[') i++;
    if (i >= len) return;
    i++; // Skip first '['
    
    while (i < len) {
        // Skip whitespace and commas
        while (i < len && (pairsStr[i] == ' ' || pairsStr[i] == ',' || pairsStr[i] == '\n')) i++;
        
        if (i >= len || pairsStr[i] == ']') break;
        
        if (pairsStr[i] == '[') {
            i++; // Skip '['
            
            // Parse first word
            while (i < len && pairsStr[i] != '"') i++; // Find opening quote
            if (i >= len) break;
            i++; // Skip opening quote
            
            int j = 0;
            while (i < len && pairsStr[i] != '"') {
                pairs[*pairCount][0][j++] = pairsStr[i++];
            }
            pairs[*pairCount][0][j] = '\0';
            
            if (i < len) i++; // Skip closing quote
            
            // Skip comma
            while (i < len && (pairsStr[i] == ',' || pairsStr[i] == ' ')) i++;
            
            // Parse second word
            while (i < len && pairsStr[i] != '"') i++; // Find opening quote
            if (i >= len) break;
            i++; // Skip opening quote
            
            j = 0;
            while (i < len && pairsStr[i] != '"') {
                pairs[*pairCount][1][j++] = pairsStr[i++];
            }
            pairs[*pairCount][1][j] = '\0';
            
            if (i < len) i++; // Skip closing quote
            
            (*pairCount)++;
            
            // Skip to closing bracket of this pair
            while (i < len && pairsStr[i] != ']') i++;
            if (i < len) i++; // Skip ']'
        } else {
            i++;
        }
    }
}

bool areSentencesSimilarTwo(char sentence1[][MAX_WORD_LEN], int sentence1Size, char sentence2[][MAX_WORD_LEN], int sentence2Size, char pairs[][2][MAX_WORD_LEN], int pairCount) {
    if (sentence1Size != sentence2Size) {
        return false;
    }
    
    // Build adjacency list
    vertex_count = 0;
    memset(graph_adj_count, 0, sizeof(graph_adj_count));
    
    for (int i = 0; i < pairCount; i++) {
        int v1 = find_vertex(pairs[i][0]);
        int v2 = find_vertex(pairs[i][1]);
        
        graph_adj[v1][graph_adj_count[v1]++] = v2;
        graph_adj[v2][graph_adj_count[v2]++] = v1;
    }
    
    // Check each position
    for (int i = 0; i < sentence1Size; i++) {
        char* word1 = sentence1[i];
        char* word2 = sentence2[i];
        if (strcmp(word1, word2) != 0) {
            int start = lookup_vertex(word1);
            int target = lookup_vertex(word2);
            
            // If either word is not in the graph, they can't be similar
            if (start == -1 || target == -1) {
                return false;
            }
            
            memset(visited, false, sizeof(visited));
            if (!dfs(start, target)) {
                return false;
            }
        }
    }
    
    return true;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[10000], line2[10000], line3[10000];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    fgets(line3, sizeof(line3), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    line3[strcspn(line3, "\n")] = 0;
    
    // Parse sentences
    static char sentence1[MAX_WORDS][MAX_WORD_LEN];
    static char sentence2[MAX_WORDS][MAX_WORD_LEN];
    int sentence1Size = 0, sentence2Size = 0;
    
    char* token = strtok(line1, ",");
    while (token != NULL) {
        strcpy(sentence1[sentence1Size++], token);
        token = strtok(NULL, ",");
    }
    
    token = strtok(line2, ",");
    while (token != NULL) {
        strcpy(sentence2[sentence2Size++], token);
        token = strtok(NULL, ",");
    }
    
    // Parse similar pairs
    static char pairs[MAX_PAIRS][2][MAX_WORD_LEN];
    int pairCount;
    parse_pairs(line3, pairs, &pairCount);
    
    bool result = areSentencesSimilarTwo(sentence1, sentence1Size, sentence2, sentence2Size, pairs, pairCount);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × (V + E))

n word comparisons, each requiring DFS through V vertices and E edges

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list and DFS recursion stack

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS for Each Pair — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler