745. Prefix and Suffix Search

Problem

Design a special dictionary that searches the words in it by a prefix and a suffix.

Implement the WordFilter class:

• WordFilter(string[] words) Initializes the object with the words in the dictionary.

• f(string pref, string suff) Returns the index of the word in the dictionary, which has the prefix pref and the suffix suff. If there is more than one valid index, return the largest of them. If there is no such word in the dictionary, return -1.

  Example 1:

Input
["WordFilter", "f"]
[[["apple"]], ["a", "e"]]
Output
[null, 0]
Explanation
WordFilter wordFilter = new WordFilter(["apple"]);
wordFilter.f("a", "e"); // return 0, because the word at index 0 has prefix = "a" and suffix = "e".

  Constraints:

• 1 <= words.length <= 10^4

• 1 <= words[i].length <= 7

• 1 <= pref.length, suff.length <= 7

• words[i], pref and suff consist of lowercase English letters only.

• At most 10^4 calls will be made to the function f.

Solution

/**
 * @param {string[]} words
 */
var WordFilter = function (words) {
  this.mapPrefix = new Map()
  this.mapSuffix = new Map()

  for (const [wordIndex, word] of words.entries()) {
    for (let i = 0; i <= word.length; i++) {
      const [prefix, suffix] = [
        word.substring(0, i),
        word.substring(word.length - i),
      ]

      if (!this.mapPrefix.has(prefix)) {
        this.mapPrefix.set(prefix, [])
      }
      if (!this.mapSuffix.has(suffix)) {
        this.mapSuffix.set(suffix, [])
      }

      this.mapPrefix.get(prefix).push(wordIndex)
      this.mapSuffix.get(suffix).push(wordIndex)
    }
  }
}

/**
 * @param {string} prefix
 * @param {string} suffix
 * @return {number}
 */
WordFilter.prototype.f = function (prefix, suffix) {
  if (!this.mapPrefix.has(prefix) || !this.mapSuffix.has(suffix)) {
    return -1
  }

  const [prefixes, suffixes] = [
    this.mapPrefix.get(prefix),
    this.mapSuffix.get(suffix),
  ]
  let [i, j] = [prefixes.length - 1, suffixes.length - 1]

  while (i >= 0 && j >= 0) {
    if (prefixes[i] < suffixes[j]) {
      j--
    } else if (prefixes[i] > suffixes[j]) {
      i--
    } else {
      return prefixes[i]
    }
  }

  return -1
}

Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).