745. Prefix and Suffix Search

• 方法0：brute force
• • Complexity
• 方法1:
• • Complexity
• 方法3: trie

Given many words, words[i] has weight i.

Design a class WordFilter that supports one function, WordFilter.f(String prefix, String suffix). It will return the word with given prefix and suffix with maximum weight. If no word exists, return -1.

Examples:

Input:

WordFilter([“apple”])

WordFilter.f(“a”, “e”) // returns 0

WordFilter.f(“b”, “”) // returns -1

Note:

1. words has length in range [1, 15000].
2. For each test case, up to words.length queries WordFilter.f may be made.
3. words[i] has length in range [1, 10].
4. prefix, suffix have lengths in range [0, 10].
5. words[i] and prefix, suffix queries consist of lowercase letters only.

方法0：brute force

思路：

将所有prefix和的不同長度組合都hashmap起來，對應值是index number。

Complexity

WordFilter: Time = O(nL^2)

Time complexity: Time = O(1)，查找時間，這裡由于詞都不長，一共最多10 * 10種。

Space complexity: O(nL^2)

class WordFilter {
private:
    unordered_map<string, int> hash;
public:
    WordFilter(vector<string>& words) {
        for (int k = 0; k < words.size(); k++) {
            int n = words[k].size();
            for (int i = 0; i <= 10 && i <= words[k].size(); i++) {
                for (int j = 0; j<= 10 && j <= words[k].size(); j++) {
                    string key = words[k].substr(0, i) + "_" + words[k].substr(n - j);
                    hash[key] = k;
                }
            }
        }
    }
    
    int f(string prefix, string suffix) {
        return hash.find(prefix + "_" + suffix) != hash.end() ? hash[prefix + "_" + suffix] : -1;
    }
};

/**
 * Your WordFilter object will be instantiated and called as such:
 * WordFilter* obj = new WordFilter(words);
 * int param_1 = obj->f(prefix,suffix);
 */
           

方法1:

思路：

将每一個單詞可能的prefix和suffix都存入hashmap<string, vector<\int>>，vector<\int> 表示的是符合這個fix所對應的單詞index清單。當查詢的時候，我們每次從兩個hash中查找到的fix 清單從後向前查，目的是找到第一個p[i] == p[j]，如果發現 p[i] 比較大，i–，如果發現p[j] 比較大，j–。

Complexity

Wordfilter: O(nL)

Time complexity: O(n), words中的單詞數量

Space complexity: O(nL)

class WordFilter {
private:
    unordered_map<string, vector<int>> prefixHash;
    unordered_map<string, vector<int>> suffixHash;
public:
    WordFilter(vector<string>& words) {
        for (int k = 0; k < words.size(); k++) {
            int n = words[k].size();
            for (int i = 0; i <= 10 && i <= n; i++) {
                string p = words[k].substr(0, i);
                prefixHash[p].push_back(k);
            }
            
            for (int j = 0; j <= 10 && j <= n; j++) {
                string s = words[k].substr(n - j);
                suffixHash[s].push_back(k);
            }
        }
    }
    
    int f(string prefix, string suffix) {
        if (prefixHash.find(prefix) == prefixHash.end() || suffixHash.find(suffix) == suffixHash.end()) return -1;
        auto p = prefixHash[prefix];
        auto s = suffixHash[suffix];
        int i = p.size() - 1, j = s.size() - 1;
        while (i >= 0 && j >= 0) {
            if (p[i] < s[j]) j--;
            else if (p[i] > s[j]) i--;
            else return p[i];
        }
        return -1;
    }
};

/**
 * Your WordFilter object will be instantiated and called as such:
 * WordFilter* obj = new WordFilter(words);
 * int param_1 = obj->f(prefix,suffix);
 */
           

方法3: trie

discussion：https://leetcode.com/problems/prefix-and-suffix-search/discuss/110045/C%2B%2B-solution-using-two-Trie-time-and-memory-efficient.

思路：

struct Trie {
    vector<int> words; // index of words
    vector<Trie *> children;
    Trie() {
        children = vector<Trie *>(26, nullptr);
    }
    // Thanks to @huahualeetcode for adding this in case of memory leak
    ~Trie() {
        for (int i = 0; i < 26; i++) {
            if (children[i]) {
                delete children[i];
            }
        }
    }
    
    void add(const string &word, size_t begin, int index) {
        words.push_back(index);
        if (begin < word.length()) {
            if (!children[word[begin] - 'a']) {
                children[word[begin] - 'a'] = new Trie();
            }
            children[word[begin] - 'a']->add(word, begin + 1, index);
        }
    }
    
    vector<int> find(const string &prefix, size_t begin) {
        if (begin == prefix.length()) {
            return words;
        } else {
            if (!children[prefix[begin] - 'a']) {
                return {};
            } else {
                return children[prefix[begin] - 'a']->find(prefix, begin + 1);
            }
        }
    }
};

class WordFilter {
public:
    WordFilter(vector<string> words) {
        forwardTrie = new Trie();
        backwardTrie = new Trie();
        for (int i = 0; i < words.size(); i++) {
            string word = words[i];
            forwardTrie->add(word, 0, i);
            reverse(word.begin(), word.end());
            backwardTrie->add(word, 0, i);
        }
    }
    
    int f(string prefix, string suffix) {
        auto forwardMatch = forwardTrie->find(prefix, 0);
        reverse(suffix.begin(), suffix.end());
        auto backwardMatch = backwardTrie->find(suffix, 0);
        // search from the back
        auto fIter = forwardMatch.rbegin(), bIter = backwardMatch.rbegin();
        while (fIter != forwardMatch.rend() && bIter != backwardMatch.rend()) {
            if (*fIter == *bIter) {
                return *fIter;
            } else if (*fIter > *bIter) {
                fIter ++;
            } else {
                bIter ++;
            }
        }
        return -1;
    }
    
private:
    Trie *forwardTrie, *backwardTrie;
};