Question

Formatted question description: https://leetcode.ca/all/244.html

 244	Shortest Word Distance II

 This is a follow up of Shortest Word Distance.
 The only difference is now you are given the list of words and
 your method will be called repeatedly many times with different parameters.

 How would you optimize it?

 Design a class which receives a list of words in the constructor,
 and implements a method that takes two words word1 and word2
 and return the shortest distance between these two words in the list.

 For example,
 Assume that words = ["practice", "makes", "perfect", "coding", "makes"].

 Given word1 = “coding”, word2 = “practice”, return 3.
 Given word1 = "makes", word2 = "coding", return 1.

 Note:
 You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.

 @tag-array

Algorithm

Need to call the function to find the shortest word distance multiple times, then the solution to the previous problem is very inefficient.

Use HashMap to create a mapping between each word and all its appearing positions, and then when looking for the shortest word distance, you only need to take out the word’s mapped position array in HashMap for pairwise comparison.

Code

Java

  • import java.util.ArrayList;
    import java.util.HashMap;
    
    public class Shortest_Word_Distance_II {
    
        public class WordDistance {
    
            HashMap<String, ArrayList<Integer>> map; // @note: duplicated cases
    
            public WordDistance(String[] words) {
    
                map = new HashMap<String, ArrayList<Integer>>();
    
                for (int i = 0; i < words.length; i++) {
                    if (map.containsKey(words[i])) {
                        map.get(words[i]).add(i);
                    } else {
                        ArrayList<Integer> list = new ArrayList<Integer>();
                        list.add(i);
                        map.put(words[i], list);
                    }
                }
            }
    
            public int shortest(String word1, String word2) {
                ArrayList<Integer> l1 = map.get(word1);
                ArrayList<Integer> l2 = map.get(word2);
    
                int result = Integer.MAX_VALUE;
    
                // better than 2 for-loop
                int p1 = 0;
                int p2 = 0;
                while (!l1.isEmpty() || !l2.isEmpty()) {
                    int v1 = l1.isEmpty() ? Integer.MAX_VALUE : l1.get(p1);
                    int v2 = l2.isEmpty() ? Integer.MAX_VALUE : l2.get(p2);
                    result = Math.min(result, Math.abs(v1 - v2));
    
                    if (v1 < v2) {
                        p1++;
                    } else {
                        p2++;
                    }
                }
    //            for (int i1 : l1) {
    //                for (int i2 : l2) {
    //                    result = Math.min(result, Math.abs(i1 - i2));
    //                }
    //            }
    
                return result;
            }
        }
    }
    
  • // OJ: https://leetcode.com/problems/shortest-word-distance-ii/
    // Time:
    //     * WordDistance: O(N)
    //     * shortest: O(N)
    // Space: O(N)
    class WordDistance {
    private:
        unordered_map<string, vector<int>> m;
    public:
        WordDistance(vector<string> words) {
            for (int i = 0; i < words.size(); ++i) {
                m[words[i]].push_back(i);
            }
        }
        int shortest(string word1, string word2) {
            auto &a = m[word1], &b = m[word2];
            int i = 0, j = 0, dist = INT_MAX;
            while (i < a.size() && j < b.size() && dist > 1) {
                dist = min(dist, abs(a[i] - b[j]));
                if (a[i] > b[j]) ++j;
                else ++i;
            }
            return dist;
        }
    };
    
  • class WordDistance(object):
      def __init__(self, words):
        """
        initialize your data structure here.
        :type words: List[str]
        """
        self.d = {}
        for i in range(0, len(words)):
          self.d[words[i]] = self.d.get(words[i], []) + [i]
    
      def shortest(self, word1, word2):
        """
        Adds a word into the data structure.
        :type word1: str
        :type word2: str
        :rtype: int
        """
        l1 = self.d[word1]
        l2 = self.d[word2]
        i = j = 0
        ans = float("inf")
        while i < len(l1) and j < len(l2):
          ans = min(ans, abs(l1[i] - l2[j]))
          if l1[i] > l2[j]:
            j += 1
          else:
            i += 1
        return ans
    
    # Your WordDistance object will be instantiated and called as such:
    # wordDistance = WordDistance(words)
    # wordDistance.shortest("word1", "word2")
    # wordDistance.shortest("anotherWord1", "anotherWord2")
    
    

All Problems

All Solutions