Shortest Word Distance II

Shortest Word Distance II - Problem

Design a data structure that will be initialized with a string array, and then it should answer queries of the shortest distance between two different strings from the array.

Implement the WordDistance class:

WordDistance(String[] wordsDict) - initializes the object with the strings array wordsDict
int shortest(String word1, String word2) - returns the shortest distance between word1 and word2 in the array wordsDict

The distance between two words is the absolute difference of their indices in the array.

Input & Output

Example 1 — Basic Operations

$ Input: wordsDict = ["practice", "makes", "perfect", "coding", "makes"], operations = [["shortest", "coding", "practice"], ["shortest", "makes", "coding"]]

› Output: [3, 1]

💡 Note: First query: "coding" is at index 3, "practice" at index 0, distance = |3-0| = 3. Second query: "makes" at indices [1,4], "coding" at index 3, minimum distance = min(|1-3|, |4-3|) = min(2,1) = 1.

Example 2 — Same Word Multiple Positions

$ Input: wordsDict = ["a", "b", "a", "b"], operations = [["shortest", "a", "b"]]

› Output: [1]

💡 Note: "a" appears at indices [0,2], "b" appears at indices [1,3]. Possible distances: |0-1|=1, |0-3|=3, |2-1|=1, |2-3|=1. Minimum is 1.

Example 3 — Adjacent Words

$ Input: wordsDict = ["hello", "world", "coding"], operations = [["shortest", "hello", "world"]]

› Output: [1]

💡 Note: "hello" at index 0, "world" at index 1. Distance = |0-1| = 1 (adjacent positions).

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

Visualization

Tap to expand

Asked in

G Google 25 in LinkedIn 15 f Facebook 12 a Amazon 8

The optimal approach uses hash map preprocessing to store each word's positions, then applies two-pointer technique to find minimum distance between position lists. Best approach: Hash Map + Two Pointers - Time: O(m+n), Space: O(n)

Common Approaches

✓ Brute Force - Linear Search Every Time

⏱️ Time: O(n) Space: O(n)

For each shortest() query, iterate through the entire wordsDict array twice - once to find all indices of word1, then again to find all indices of word2, then compute minimum distance between any pair.

Hash Map Preprocessing

⏱️ Time: O(m + n) Space: O(n)

Build a hash map during initialization where each word maps to a list of all its indices. For each query, retrieve the position lists in O(1) time and find minimum distance between the two lists.

Brute Force - Linear Search Every Time — Algorithm Steps

Step 1: Store the wordsDict array as-is
Step 2: For each query, find all indices of word1 by scanning array
Step 3: Find all indices of word2 by scanning array again
Step 4: Compare all pairs to find minimum distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Array

Keep original wordsDict as-is

Linear Search

For each query, scan entire array to find word positions

Compare All Pairs

Check every combination to find minimum distance

Code -

solution.c — C

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

static char words[1000][100];
static int wordCount = 0;

typedef struct {
    int dummy;
} WordDistance;

WordDistance* wordDistanceCreate(char** wordsDict, int wordsDictSize) {
    WordDistance* obj = (WordDistance*)malloc(sizeof(WordDistance));
    wordCount = wordsDictSize;
    for (int i = 0; i < wordsDictSize; i++) {
        strcpy(words[i], wordsDict[i]);
    }
    return obj;
}

int wordDistanceShortest(WordDistance* obj, char* word1, char* word2) {
    static int indices1[1000], indices2[1000];
    int count1 = 0, count2 = 0;
    
    // Find all indices of word1
    for (int i = 0; i < wordCount; i++) {
        if (strcmp(words[i], word1) == 0) {
            indices1[count1++] = i;
        }
    }
    
    // Find all indices of word2
    for (int i = 0; i < wordCount; i++) {
        if (strcmp(words[i], word2) == 0) {
            indices2[count2++] = i;
        }
    }
    
    // Find minimum distance
    int minDist = INT_MAX;
    for (int i = 0; i < count1; i++) {
        for (int j = 0; j < count2; j++) {
            int dist = indices1[i] - indices2[j];
            if (dist < 0) dist = -dist;
            if (dist < minDist) {
                minDist = dist;
            }
        }
    }
    
    return minDist;
}

int* solution(char** wordsDict, int wordsDictSize, char*** operations, int operationsSize, int* returnSize) {
    WordDistance* wd = wordDistanceCreate(wordsDict, wordsDictSize);
    static int results[1000];
    int resultCount = 0;
    
    for (int i = 0; i < operationsSize; i++) {
        if (strcmp(operations[i][0], "shortest") == 0) {
            results[resultCount++] = wordDistanceShortest(wd, operations[i][1], operations[i][2]);
        }
    }
    
    *returnSize = resultCount;
    free(wd);
    return results;
}

static char wordsBuffer[10000];
static char opsBuffer[10000];
static char* wordArray[1000];
static char* opArray[1000][10];
static char** operations[1000];

int main() {
    if (!fgets(wordsBuffer, sizeof(wordsBuffer), stdin)) return 1;
    if (!fgets(opsBuffer, sizeof(opsBuffer), stdin)) return 1;
    
    // Parse words
    int wordCount = 0;
    char* p = wordsBuffer;
    while (*p && *p != '[') p++; p++; // Skip to after '['
    
    while (*p && *p != ']') {
        while (*p && (*p == ' ' || *p == ',' || *p == '\"')) p++;
        if (*p == ']') break;
        
        char* start = p;
        while (*p && *p != '\"' && *p != ',' && *p != ']') p++;
        
        int len = p - start;
        wordArray[wordCount] = (char*)malloc(len + 1);
        strncpy(wordArray[wordCount], start, len);
        wordArray[wordCount][len] = '\0';
        wordCount++;
        
        while (*p && (*p == '\"' || *p == ',' || *p == ' ')) p++;
    }
    
    // Parse operations
    int opCount = 0;
    p = opsBuffer;
    while (*p && *p != '[') p++; p++; // Skip to after '['
    
    while (*p && *p != ']') {
        while (*p && (*p == ' ' || *p == ',')) p++;
        if (*p == '[') {
            p++; // Skip '['
            int argCount = 0;
            while (*p && *p != ']') {
                while (*p && (*p == ' ' || *p == ',' || *p == '\"')) p++;
                if (*p == ']') break;
                
                char* start = p;
                while (*p && *p != '\"' && *p != ',' && *p != ']') p++;
                
                int len = p - start;
                opArray[opCount][argCount] = (char*)malloc(len + 1);
                strncpy(opArray[opCount][argCount], start, len);
                opArray[opCount][argCount][len] = '\0';
                argCount++;
                
                while (*p && (*p == '\"' || *p == ',' || *p == ' ')) p++;
            }
            operations[opCount] = opArray[opCount];
            opCount++;
            if (*p == ']') p++;
        } else {
            p++;
        }
    }
    
    int returnSize;
    int* result = solution(wordArray, wordCount, operations, opCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each shortest() call scans the entire array twice to find word positions

✓ Linear Growth

Space Complexity

O(n)

Only stores the original wordsDict array

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 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 - Linear Search Every Time — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler