Alien Dictionary

Alien Dictionary - Problem

Array String Depth-First Search Breadth-First Search Graph Topological Sort Hard

There is a new alien language that uses the English alphabet. However, the order of the letters is unknown to you.

You are given a list of strings words from the alien language's dictionary. Now it is claimed that the strings in words are sorted lexicographically by the rules of this new language.

If this claim is incorrect, and the given arrangement of string in words cannot correspond to any order of letters, return "". Otherwise, return a string of the unique letters in the new alien language sorted in lexicographically increasing order by the new language's rules.

If there are multiple solutions, return any of them.

Input & Output

Example 1 — Basic Alien Dictionary

$ Input: words = ["wrt","wrf","er","ett","rftt"]

› Output: "wertf"

💡 Note: From "wrt" and "wrf", we get t->f. From "wrf" and "er", we get w->e. From "er" and "ett", we get r->t. From "ett" and "rftt", we get e->r. So the order is w->e->r->t->f, giving "wertf".

Example 2 — Simple Two Letters

$ Input: words = ["z","x"]

› Output: "zx"

💡 Note: From "z" and "x", we get z comes before x in alien language ordering.

Example 3 — Invalid Dictionary

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

› Output: ""

💡 Note: "abc" cannot come before "ab" in any valid dictionary ordering since "abc" has "ab" as prefix but is longer.

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 85 f Facebook 72 a Amazon 65 M Microsoft 58

The Alien Dictionary problem requires finding the lexicographical order of letters in an alien language. The key insight is to build a dependency graph by comparing adjacent words and use topological sort to find valid ordering. Best approach is topological sort with cycle detection using Kahn's algorithm or DFS. Time: O(N×M + V + E), Space: O(V + E).

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × n × m) Space: O(n!)

Try every possible permutation of the unique letters and check if each permutation produces the given word ordering when used for lexicographical comparison.

DFS with Cycle Detection

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

Build dependency graph and use DFS with three states (unvisited, visiting, visited) to detect cycles and generate topological ordering through post-order traversal.

Topological Sort (Graph-Based)

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

Compare adjacent words to build a directed graph representing letter precedence relationships, then use topological sort to find valid ordering. If cycle detected, return empty string.

Brute Force - Try All Permutations — Algorithm Steps

Find all unique letters
Generate all permutations of letters
For each permutation, check if it produces the given word order

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Letters

Find unique letters: w, r, t, f

Generate Permutations

Try all 24 possible orderings

Test Each Order

Check if permutation satisfies word order

Return Valid Order

First valid permutation is the answer

Code -

solution.c — C

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

#define MAX_WORDS 100
#define MAX_WORD_LEN 100
#define MAX_CHARS 26

char words[MAX_WORDS][MAX_WORD_LEN];
int word_count = 0;
char unique_chars[MAX_CHARS];
int char_count = 0;

bool is_sorted(const char* word1, const char* word2, int* order) {
    int len1 = strlen(word1), len2 = strlen(word2);
    int min_len = len1 < len2 ? len1 : len2;
    
    for (int i = 0; i < min_len; i++) {
        int pos1 = order[word1[i] - 'a'];
        int pos2 = order[word2[i] - 'a'];
        if (pos1 < pos2) return true;
        if (pos1 > pos2) return false;
    }
    
    return len1 <= len2;
}

void swap_chars(char* a, char* b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

bool try_permutation(int start, char* result) {
    if (start == char_count) {
        // Create order mapping
        int order[26];
        for (int i = 0; i < 26; i++) order[i] = -1;
        for (int i = 0; i < char_count; i++) {
            order[unique_chars[i] - 'a'] = i;
        }
        
        // Check if this order works
        for (int i = 0; i < word_count - 1; i++) {
            if (!is_sorted(words[i], words[i + 1], order)) {
                return false;
            }
        }
        
        // Copy result
        strncpy(result, unique_chars, char_count);
        result[char_count] = '\0';
        return true;
    }
    
    for (int i = start; i < char_count; i++) {
        swap_chars(&unique_chars[start], &unique_chars[i]);
        if (try_permutation(start + 1, result)) {
            return true;
        }
        swap_chars(&unique_chars[start], &unique_chars[i]);
    }
    
    return false;
}

char* solution() {
    if (word_count == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    // Find unique characters
    bool seen[26] = {false};
    char_count = 0;
    
    for (int i = 0; i < word_count; i++) {
        for (int j = 0; words[i][j]; j++) {
            if (!seen[words[i][j] - 'a']) {
                seen[words[i][j] - 'a'] = true;
                unique_chars[char_count++] = words[i][j];
            }
        }
    }
    
    // Try permutations
    char* result = malloc(char_count + 1);
    if (try_permutation(0, result)) {
        return result;
    }
    
    result[0] = '\0';
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array manually
    char* start = strchr(line, '[');
    char* end = strrchr(line, ']');
    if (start && end) {
        start++;
        *end = '\0';
        
        char* token = strtok(start, ",");
        while (token && word_count < MAX_WORDS) {
            // Remove quotes and spaces
            while (*token == ' ' || *token == '"') token++;
            char* word_end = token + strlen(token) - 1;
            while (word_end > token && (*word_end == ' ' || *word_end == '"')) {
                *word_end = '\0';
                word_end--;
            }
            
            if (strlen(token) > 0) {
                strcpy(words[word_count], token);
                word_count++;
            }
            
            token = strtok(NULL, ",");
        }
    }
    
    char* result = solution();
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n × m)

n! permutations, each requiring O(n×m) to validate against word list

✓ Linear Growth

Space Complexity

O(n!)

Storing all permutations where n is number of unique letters

✓ Linear Space

285.0K Views

High Frequency

~35 min Avg. Time

2.8K 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 - Try All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler