Shortest Word Distance II - Practice Coding Problems

Shortest Word Distance II - Problem

You're building a smart dictionary system that needs to quickly find the shortest distance between any two words in a text corpus. Given an array of strings representing words, you need to design a data structure that can efficiently answer multiple queries about the minimum distance between different word pairs.

The Challenge: Design the WordDistance class that supports:

WordDistance(String[] wordsDict) - Initialize with an array of words
int shortest(String word1, String word2) - Return the shortest distance between word1 and word2

The distance between two words is the absolute difference between their indices in the array. Since multiple queries will be made, your solution should optimize for query time efficiency.

Example: If wordsDict = ["practice", "makes", "perfect", "coding", "makes"], then shortest("makes", "coding") should return 1 because the closest occurrence of "makes" is at index 4 and "coding" is at index 3, giving us |4-3| = 1.

Input & Output

example_1.py — Basic Usage

$ Input: wordsDict = ["practice", "makes", "perfect", "coding", "makes"] word1 = "makes", word2 = "coding"

› Output: 1

💡 Note: The word "makes" appears at indices 1 and 4, while "coding" appears at index 3. The shortest distance is between indices 4 and 3, which is |4-3| = 1.

example_2.py — Multiple Queries

$ Input: wordsDict = ["practice", "makes", "perfect", "coding", "makes"] word1 = "practice", word2 = "makes"

› Output: 1

💡 Note: "practice" is at index 0, "makes" appears at indices 1 and 4. The shortest distance is between indices 0 and 1, which is |0-1| = 1.

example_3.py — Distant Words

$ Input: wordsDict = ["practice", "makes", "perfect", "coding", "makes"] word1 = "practice", word2 = "perfect"

› Output: 2

💡 Note: "practice" is at index 0, "perfect" is at index 2. The distance is |0-2| = 2.

Visualization

Tap to expand

Understanding the Visualization

Build Catalog

Create a comprehensive index mapping each book title to all shelf positions

Quick Lookup

When asked about two books, instantly retrieve their position lists from the catalog

Smart Comparison

Use two-finger technique to efficiently find the minimum walking distance

Key Takeaway

🎯 Key Insight: Preprocess once with hash map, then use two pointers for O(m+n) queries - perfect for systems with many lookups!

Time & Space Complexity

Time Complexity

⏱️

O(n) preprocessing, O(m + n) per query

Preprocessing takes O(n) to build hash map. Each query takes O(m + n) where m and n are frequencies of the two words

✓ Linear Growth

Space Complexity

O(n)

Hash map stores all positions, which in worst case is O(n) space

⚡ Linearithmic Space

Constraints

1 ≤ wordsDict.length ≤ 3 × 10⁴
1 ≤ wordsDict[i].length ≤ 10
wordsDict[i] consists of lowercase English letters
word1 and word2 are in wordsDict
word1 ≠ word2
At most 5000 calls will be made to shortest

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal approach uses a hash map with position lists during initialization, then two pointers during queries. This achieves O(m + n) query time where m and n are word frequencies, making it highly efficient for multiple queries on the same dataset.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map with Position Lists (Optimal)	O(n) preprocessing, O(m + n) per query	O(n)	Preprocess words into hash map of position lists, then use two pointers for efficient queries
Brute Force (Linear Search Every Query)	O(n) per query	O(1)	Scan entire array for each query to find all positions and calculate minimum distance

Hash Map with Position Lists (Optimal) — Algorithm Steps

Initialize hash map to store word -> list of positions
Iterate through input array once to populate position lists
For each query, retrieve position lists for both words
Use two pointers on the sorted position lists
Move pointer of smaller value to minimize distance
Track and return minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

Create word -> position list mapping during initialization

Retrieve Lists

Get position lists for both query words

Two Pointer Scan

Use two pointers to efficiently find minimum distance

Code -

solution.c — C

typedef struct {
    char** words;
    int** positions;
    int* positionSizes;
    int uniqueWords;
} WordDistance;

WordDistance* wordDistanceCreate(char** wordsDict, int wordsDictSize) {
    WordDistance* obj = (WordDistance*)malloc(sizeof(WordDistance));
    obj->words = (char**)malloc(wordsDictSize * sizeof(char*));
    obj->positions = (int**)malloc(wordsDictSize * sizeof(int*));
    obj->positionSizes = (int*)calloc(wordsDictSize, sizeof(int));
    obj->uniqueWords = 0;
    
    // Build position lists for each unique word
    for (int i = 0; i < wordsDictSize; i++) {
        int wordIndex = -1;
        // Find if word already exists
        for (int j = 0; j < obj->uniqueWords; j++) {
            if (strcmp(obj->words[j], wordsDict[i]) == 0) {
                wordIndex = j;
                break;
            }
        }
        
        if (wordIndex == -1) {
            // New word
            wordIndex = obj->uniqueWords++;
            obj->words[wordIndex] = wordsDict[i];
            obj->positions[wordIndex] = (int*)malloc(wordsDictSize * sizeof(int));
        }
        
        obj->positions[wordIndex][obj->positionSizes[wordIndex]++] = i;
    }
    
    return obj;
}

int wordDistanceShortest(WordDistance* obj, char* word1, char* word2) {
    int idx1 = -1, idx2 = -1;
    
    // Find word indices
    for (int i = 0; i < obj->uniqueWords; i++) {
        if (strcmp(obj->words[i], word1) == 0) idx1 = i;
        if (strcmp(obj->words[i], word2) == 0) idx2 = i;
    }
    
    // Use two pointers
    int i = 0, j = 0;
    int minDist = INT_MAX;
    
    while (i < obj->positionSizes[idx1] && j < obj->positionSizes[idx2]) {
        int dist = abs(obj->positions[idx1][i] - obj->positions[idx2][j]);
        if (dist < minDist) minDist = dist;
        
        if (obj->positions[idx1][i] < obj->positions[idx2][j]) {
            i++;
        } else {
            j++;
        }
    }
    
    return minDist;
}

void wordDistanceFree(WordDistance* obj) {
    for (int i = 0; i < obj->uniqueWords; i++) {
        free(obj->positions[i]);
    }
    free(obj->words);
    free(obj->positions);
    free(obj->positionSizes);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n) preprocessing, O(m + n) per query

Preprocessing takes O(n) to build hash map. Each query takes O(m + n) where m and n are frequencies of the two words

✓ Linear Growth

Space Complexity

O(n)

Hash map stores all positions, which in worst case is O(n) space

⚡ Linearithmic Space

Constraints

1 ≤ wordsDict.length ≤ 3 × 10⁴
1 ≤ wordsDict[i].length ≤ 10
wordsDict[i] consists of lowercase English letters
word1 and word2 are in wordsDict
word1 ≠ word2
At most 5000 calls will be made to shortest

42.3K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Hash Map with Position Lists (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler