Synonymous Sentences

Synonymous Sentences - Problem

Array Hash Table String Backtracking Sorting Union Find Medium

You are given a list of equivalent string pairs synonyms where synonyms[i] = [s_i, t_i] indicates that s_i and t_i are equivalent strings. You are also given a sentence text.

Return all possible synonymous sentences sorted lexicographically.

A synonymous sentence is formed by replacing zero or more words in the original sentence with their synonyms.

Input & Output

Example 1 — Basic Synonyms

$ Input: synonyms = [["happy","joy"],["sad","sorrow"],["joy","cheerful"]], text = "I am happy today"

› Output: ["I am cheerful today","I am happy today","I am joy today"]

💡 Note: The word 'happy' can be replaced with 'joy' or 'cheerful' (since happy↔joy↔cheerful are all connected). The other words remain unchanged.

Example 2 — Multiple Words with Synonyms

$ Input: synonyms = [["happy","joy"],["cheerful","content"]], text = "I am happy today"

› Output: ["I am happy today","I am joy today"]

💡 Note: Only 'happy' has synonyms in this case. The pairs [happy,joy] and [cheerful,content] are separate groups since they're not connected.

Example 3 — No Synonyms Found

$ Input: synonyms = [["a","b"],["c","d"]], text = "I like coding"

› Output: ["I like coding"]

💡 Note: None of the words in the sentence have synonyms in the given list, so only the original sentence is returned.

Constraints

0 ≤ synonyms.length ≤ 10
synonyms[i].length == 2
1 ≤ synonyms[i][j].length, text.length ≤ 10
synonyms[i][0] ≠ synonyms[i][1]
text consists of at most 10 words

Visualization

Tap to expand

Asked in

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

The key insight is to group all transitively connected synonyms using Union Find, then use backtracking to generate all possible sentence combinations. Best approach uses Union Find + Backtracking for efficient synonym grouping. Time: O(S×α(S) + k^n × L), Space: O(S + k^n × L)

Common Approaches

✓ Brute Force with Backtracking

⏱️ Time: O(k^n × L) Space: O(k^n × L)

For each word in the sentence, find all its synonyms by checking every synonym pair. Then recursively generate all possible sentences by trying each synonym option.

Optimized Backtracking with Union Find

⏱️ Time: O(S×α(S) + k^n × L) Space: O(S + k^n × L)

First build synonym groups using Union Find to handle transitive relationships (if A=B and B=C, then A=C). Then use backtracking to generate all possible sentences from these groups.

Brute Force with Backtracking — Algorithm Steps

For each word, scan all synonym pairs to find alternatives
Recursively generate all combinations
Sort results lexicographically

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Input

Split sentence into words and identify synonyms

Backtrack

For each word, try all possible synonyms recursively

Collect Results

Sort all generated sentences lexicographically

Code -

solution.c — C

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

#define MAX_WORDS 20
#define MAX_SYNONYMS 20
#define MAX_RESULTS 10000
#define MAX_LEN 100
#define MAX_GRAPH_NODES 100

static char synonyms[MAX_SYNONYMS][2][MAX_LEN];
static int synonymCount = 0;
static char words[MAX_WORDS][MAX_LEN];
static int wordCount = 0;
static char results[MAX_RESULTS][MAX_LEN * MAX_WORDS];
static int resultCount = 0;
static char graph[MAX_GRAPH_NODES][MAX_GRAPH_NODES][MAX_LEN];
static int graphSizes[MAX_GRAPH_NODES];
static char nodeNames[MAX_GRAPH_NODES][MAX_LEN];
static int nodeCount = 0;

int findNodeIndex(const char* word) {
    for (int i = 0; i < nodeCount; i++) {
        if (strcmp(nodeNames[i], word) == 0) {
            return i;
        }
    }
    strcpy(nodeNames[nodeCount], word);
    graphSizes[nodeCount] = 0;
    return nodeCount++;
}

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

void dfs(int nodeIdx, int* visited, char synonymsSet[][MAX_LEN], int* synonymsSetSize) {
    if (visited[nodeIdx]) return;
    visited[nodeIdx] = 1;
    strcpy(synonymsSet[(*synonymsSetSize)++], nodeNames[nodeIdx]);
    
    for (int i = 0; i < graphSizes[nodeIdx]; i++) {
        int neighborIdx = -1;
        for (int j = 0; j < nodeCount; j++) {
            if (strcmp(nodeNames[j], graph[nodeIdx][i]) == 0) {
                neighborIdx = j;
                break;
            }
        }
        if (neighborIdx != -1) {
            dfs(neighborIdx, visited, synonymsSet, synonymsSetSize);
        }
    }
}

void findSynonyms(const char* word, char synonymsList[][MAX_LEN], int* synonymsListSize) {
    int visited[MAX_GRAPH_NODES];
    char synonymsSet[MAX_GRAPH_NODES][MAX_LEN];
    int synonymsSetSize = 0;
    
    for (int i = 0; i < nodeCount; i++) {
        visited[i] = 0;
    }
    
    int wordIdx = getNodeIndex(word);
    if (wordIdx == -1) {
        // Word not in synonym graph, return just the word itself
        strcpy(synonymsList[0], word);
        *synonymsListSize = 1;
        return;
    }
    
    dfs(wordIdx, visited, synonymsSet, &synonymsSetSize);
    
    // Sort synonyms
    for (int i = 0; i < synonymsSetSize - 1; i++) {
        for (int j = i + 1; j < synonymsSetSize; j++) {
            if (strcmp(synonymsSet[i], synonymsSet[j]) > 0) {
                char temp[MAX_LEN];
                strcpy(temp, synonymsSet[i]);
                strcpy(synonymsSet[i], synonymsSet[j]);
                strcpy(synonymsSet[j], temp);
            }
        }
    }
    
    *synonymsListSize = synonymsSetSize;
    for (int i = 0; i < synonymsSetSize; i++) {
        strcpy(synonymsList[i], synonymsSet[i]);
    }
}

void backtrack(int index, char current[][MAX_LEN]) {
    if (index == wordCount) {
        char sentence[MAX_LEN * MAX_WORDS] = "";
        for (int i = 0; i < wordCount; i++) {
            if (i > 0) strcat(sentence, " ");
            strcat(sentence, current[i]);
        }
        strcpy(results[resultCount++], sentence);
        return;
    }
    
    char wordSynonyms[MAX_SYNONYMS][MAX_LEN];
    int synonymsListSize;
    findSynonyms(words[index], wordSynonyms, &synonymsListSize);
    
    for (int i = 0; i < synonymsListSize; i++) {
        strcpy(current[index], wordSynonyms[i]);
        backtrack(index + 1, current);
    }
}

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

int main() {
    char line[2000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse synonyms array
    char *ptr = line;
    
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Parse each synonym pair
    while (*ptr && synonymCount < MAX_SYNONYMS) {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',' || *ptr == '\t') ptr++;
        
        if (*ptr == ']') break;  // End of array
        
        if (*ptr == '[') {
            ptr++; // skip '['
            
            // Parse first synonym
            while (*ptr == ' ' || *ptr == '\t') ptr++;  // skip whitespace
            if (*ptr == '"') ptr++;  // skip opening quote
            
            char *start = ptr;
            while (*ptr && *ptr != '"') ptr++;  // find closing quote
            int len = ptr - start;
            strncpy(synonyms[synonymCount][0], start, len);
            synonyms[synonymCount][0][len] = '\0';
            
            if (*ptr == '"') ptr++;  // skip closing quote
            
            // Skip to comma
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;  // skip comma
            
            // Parse second synonym
            while (*ptr == ' ' || *ptr == '\t') ptr++;  // skip whitespace
            if (*ptr == '"') ptr++;  // skip opening quote
            
            start = ptr;
            while (*ptr && *ptr != '"') ptr++;  // find closing quote
            len = ptr - start;
            strncpy(synonyms[synonymCount][1], start, len);
            synonyms[synonymCount][1][len] = '\0';
            
            if (*ptr == '"') ptr++;  // skip closing quote
            
            // Build graph
            int idx1 = findNodeIndex(synonyms[synonymCount][0]);
            int idx2 = findNodeIndex(synonyms[synonymCount][1]);
            strcpy(graph[idx1][graphSizes[idx1]++], synonyms[synonymCount][1]);
            strcpy(graph[idx2][graphSizes[idx2]++], synonyms[synonymCount][0]);
            
            synonymCount++;
            
            // Skip to ']'
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
        } else {
            break;
        }
    }
    
    // Read text line
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse words
    char *token = strtok(line, " ");
    while (token) {
        strcpy(words[wordCount++], token);
        token = strtok(NULL, " ");
    }
    
    char current[MAX_WORDS][MAX_LEN];
    backtrack(0, current);
    
    // Remove duplicates
    int uniqueCount = 0;
    for (int i = 0; i < resultCount; i++) {
        int isDuplicate = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (strcmp(results[i], results[j]) == 0) {
                isDuplicate = 1;
                break;
            }
        }
        if (!isDuplicate) {
            strcpy(results[uniqueCount++], results[i]);
        }
    }
    resultCount = uniqueCount;
    
    qsort(results, resultCount, sizeof(results[0]), compare);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", results[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n × L)

k synonyms per word, n words, L for string operations and sorting

✓ Linear Growth

Space Complexity

O(k^n × L)

Store all possible sentences, each of length L

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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 with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler