You are given an array nums consisting of non-negative integers. You are also given a queries array, where queries[i] = [xi, mi].

The answer to the ith query is the maximum bitwise XOR value of xi and any element of nums that does not exceed mi. In other words, the answer is max(nums[j] XOR xi) for all j such that nums[j] <= mi. If all elements in nums are larger than mi, then the answer is -1.

Return an integer array answer where answer.length == queries.length and answer[i] is the answer to the ith query.

Example 1:

Input: nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]
Output: [3,3,7]
Explanation:
1) 0 and 1 are the only two integers not greater than 1. 0 XOR 3 = 3 and 1 XOR 3 = 2. The larger of the two is 3.
2) 1 XOR 2 = 3.
3) 5 XOR 2 = 7.

Example 2:

Input: nums = [5,2,4,6,6,3], queries = [[12,4],[8,1],[6,3]]
Output: [15,-1,5]

Constraints:

• 1 <= nums.length, queries.length <= 105
• queries[i].length == 2
• 0 <= nums[j], xi, mi <= 109

Solution: Trie on the fly

Similar idea to https://zxi.mytechroad.com/blog/trie/leetcode-421-maximum-xor-of-two-numbers-in-an-array/

We can build the trie on the fly by sorting nums in ascending order and queries by its limit, insert nums into the trie up the limit.

Time complexity: O(nlogn + QlogQ)
Space complexity: O(n)

// Author: Huahua
class Trie {
public:
  Trie(): children{nullptr, nullptr} {}  
  Trie* children[2];
};
class Solution {
public:
  vector<int> maximizeXor(vector<int>& nums, vector<vector<int>>& queries) {
    const int n = nums.size();
    sort(begin(nums), end(nums));    
    
    const int Q = queries.size();
    for (int i = 0; i < Q; ++i)
      queries[i].push_back(i);
    sort(begin(queries), end(queries), [](const auto& q1, const auto& q2) {
      return q1[1] < q2[1];
    });
    
    Trie root;    
    auto insert = [&](int num) {
      Trie* node = &root; 
      for (int i = 31; i >= 0; --i) {
        int bit = (num >> i) & 1;
        if (!node->children[bit])
          node->children[bit] = new Trie();
        node = node->children[bit];
      }
    };
        
    auto query = [&](int num) {
      Trie* node = &root;
      int sum = 0;
      for (int i = 31; i >= 0; --i) {
        if (!node) return -1;
        int bit = (num >> i) & 1;
        if (node->children[1 - bit]) {
          sum |= (1 << i);
          node = node->children[1 - bit];
        } else {
          node = node->children[bit];
        }
      }
      return sum;
    };
    
    vector<int> ans(Q);
    int i = 0;
    for (const auto& q : queries) {
      while (i < n && nums[i] <= q[1]) insert(nums[i++]);
      ans[q[2]] = query(q[0]);
    }  
    return ans;
  }
};

The post 花花酱 LeetCode 1707. Maximum XOR With an Element From Array appeared first on Huahua's Tech Road.

Follow up: Could you do this in O(n) runtime?

Example 1:

Input: nums = [3,10,5,25,2,8]
Output: 28
Explanation: The maximum result is 5 XOR 25 = 28.

Example 2:

Input: nums = [0]
Output: 0

Example 3:

Input: nums = [2,4]
Output: 6

Example 4:

Input: nums = [8,10,2]
Output: 10

Example 5:

Input: nums = [14,70,53,83,49,91,36,80,92,51,66,70]
Output: 127

Constraints:

• 1 <= nums.length <= 2 * 104
• 0 <= nums[i] <= 231 - 1

Solution: Trie

Time complexity: O(31*2*n)
Space complexity: O(31*2*n)

// Author: Huahua
class Trie {
public:
  Trie(): children(2) {}  
  vector<unique_ptr<Trie>> children;
};
class Solution {
public:
  int findMaximumXOR(vector<int>& nums) {
    Trie root;
    
    // Insert a number into the trie.
    auto insert = [&](Trie* node, int num) {
      for (int i = 31; i >= 0; --i) {
        int bit = (num >> i) & 1;
        if (!node->children[bit])
          node->children[bit] = std::make_unique<Trie>();
        node = node->children[bit].get();
      }
    };
  
    // Find max xor sum of num and another element in the array.
    auto query = [&](Trie* node, int num) {
      int sum = 0;
      for (int i = 31; i >= 0; --i) {
        int bit = (num >> i) & 1;
        if (node->children[1 - bit]) {
          sum += (1 << i);
          node = node->children[1 - bit].get();
        } else {
          node = node->children[bit].get();
        }
      }
      return sum;
    };
    
    // Insert all numbers.
    for (int x : nums) 
      insert(&root, x);
    
    int ans = 0;
    // For each number find the maximum xor sum.
    for (int x : nums) 
      ans = max(ans, query(&root, x));
    return ans;
  }
};

The post 花花酱 LeetCode 421. Maximum XOR of Two Numbers in an Array appeared first on Huahua's Tech Road.

Given an array of strings products and a string searchWord. We want to design a system that suggests at most three product names from products after each character of searchWord is typed. Suggested products should have common prefix with the searchWord. If there are more than three products with a common prefix return the three lexicographically minimums products.

Return list of lists of the suggested products after each character of searchWord is typed. 

Example 1:

Input: products = ["mobile","mouse","moneypot","monitor","mousepad"], searchWord = "mouse"
Output: [
["mobile","moneypot","monitor"],
["mobile","moneypot","monitor"],
["mouse","mousepad"],
["mouse","mousepad"],
["mouse","mousepad"]
]
Explanation: products sorted lexicographically = ["mobile","moneypot","monitor","mouse","mousepad"]
After typing m and mo all products match and we show user ["mobile","moneypot","monitor"]
After typing mou, mous and mouse the system suggests ["mouse","mousepad"]

Example 2:

Input: products = ["havana"], searchWord = "havana"
Output: [["havana"],["havana"],["havana"],["havana"],["havana"],["havana"]]

Example 3:

Input: products = ["bags","baggage","banner","box","cloths"], searchWord = "bags"
Output: [["baggage","bags","banner"],["baggage","bags","banner"],["baggage","bags"],["bags"]]

Example 4:

Input: products = ["havana"], searchWord = "tatiana"
Output: [[],[],[],[],[],[],[]]

Constraints:

• 1 <= products.length <= 1000
• 1 <= Σ products[i].length <= 2 * 10^4
• All characters of products[i] are lower-case English letters.
• 1 <= searchWord.length <= 1000
• All characters of searchWord are lower-case English letters.

Solution 1: Binary Search

Sort the input array and do two binary searches.
One for prefix of the search word as lower bound, another for prefix + ‘~’ as upper bound.
‘~’ > ‘z’

Time complexity: O(nlogn + l * logn)
Space complexity: O(1)

// Author: Huahua, 36ms, 35MB
class Solution {
public:
  vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord) {
    vector<vector<string>> ans;
    std::sort(begin(products), end(products));
    string key;
    for (char c : searchWord) {
      key += c;      
      auto l = lower_bound(begin(products), end(products), key);
      auto r = upper_bound(begin(products), end(products), key += '~');
      if (l == r) break; // early return
      key.pop_back();
      ans.emplace_back(l, min(l + 3, r));
    }
    while (ans.size() != searchWord.length()) ans.push_back({});
    return ans;
  }
};

Solution 2: Trie

Initialization: Sum(len(products[i]))
Query: O(len(searchWord))

// Author: Huahua, 148 ms, 98.8 MB
struct Trie {
  Trie(): nodes(26) {}
  ~Trie() { 
    for (auto* node : nodes)
      delete node;
  }
  vector<Trie*> nodes;
  vector<const string*> words;  
  
  static void addWord(Trie* root, const string& word) {    
    for (char c : word) {      
      if (root->nodes[c - 'a'] == nullptr) root->nodes[c - 'a'] = new Trie();
      root = root->nodes[c - 'a'];
      if (root->words.size() < 3)
        root->words.push_back(&word);
    }
  }
  
  static vector<vector<string>> getWords(Trie* root, const string& prefix) {
    vector<vector<string>> ans(prefix.size());
    for (int i = 0; i < prefix.size(); ++i) {
      char c = prefix[i];
      root = root->nodes[c - 'a'];
      if (root == nullptr) break;
      for (auto* word : root->words)
        ans[i].push_back(*word);
    }
    return ans;
  }
};

class Solution {
public:
  vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord) {
    std::sort(begin(products), end(products));
    Trie root;
    for (const auto& product : products)
      Trie::addWord(&root, product);
    return Trie::getWords(&root, searchWord);
  }
};

The post 花花酱 LeetCode 1268. Search Suggestions System appeared first on Huahua's Tech Road.

Given a 2D board and a list of words from the dictionary, find all words in the board.

Each word must be constructed from letters of sequentially adjacent cell, where “adjacent” cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.

Example:

Input: 
board = [
  ['o','a','a','n'],
  ['e','t','a','e'],
  ['i','h','k','r'],
  ['i','f','l','v']
]
words = ["oath","pea","eat","rain"]

Output: ["eat","oath"]

Note:

1. All inputs are consist of lowercase letters a-z.
2. The values of words are distinct.

Solution 1: DFS

Time complexity: O(sum(m*n*4^l))
Space complexity: O(l)

// Author: Huahua, 708 ms, 15.3 MB
class Solution {
public:
  vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
    unordered_set<string> unique_words(words.begin(), words.end());
    vector<string> ans;
    for (const string& word : unique_words)
      if (exist(board, word))
        ans.push_back(word);
    return ans;
  }
private:
  int w;
  int h;
  bool exist(vector<vector<char>> &board, string word) {
    if (board.size() == 0) return false;
    h = board.size();
    w = board[0].size();
    for (int i = 0 ; i < w; i++)
      for (int j = 0 ; j < h; j++)
        if (search(board, word, 0, i, j)) return true;
    return false;
  }
    
  bool search(vector<vector<char>> &board, 
           const string& word, int d, int x, int y) {
    if (x < 0 || x == w || y < 0 || y == h || word[d] != board[y][x]) 
      return false;

    // Found the last char of the word
    if (d == word.length() - 1)
      return true;

    char cur = board[y][x];
    board[y][x] = '#'; 
    bool found = search(board, word, d + 1, x + 1, y)
              || search(board, word, d + 1, x - 1, y)
              || search(board, word, d + 1, x, y + 1)
              || search(board, word, d + 1, x, y - 1);
    board[y][x] = cur;
    return found;
  }
};

Solution 2: Trie

Store all the words into a trie, search the board using DFS, paths must be in the trie otherwise there is no need to explore.

Time complexity: O(sum(l) + 4^max(l))
space complexity: O(sum(l) + l)

// Author: Huahua, 64 ms, 35.6 MB
class TrieNode {
public:
  vector<TrieNode*> nodes;  
  const string* word;
  TrieNode(): nodes(26), word(nullptr) {}
  ~TrieNode() {
    for (auto node : nodes) delete node;
  }  
};
class Solution {
public:
  vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
    TrieNode root;
    
    // Add all the words into Trie.
    for (const string& word : words) {
      TrieNode* cur = &root;
      for (char c : word) {
        auto& next = cur->nodes[c - 'a'];
        if (!next) next = new TrieNode();
        cur = next;
      }
      cur->word = &word;
    }
    
    const int n = board.size();
    const int m = board[0].size();    
    vector<string> ans;
    
    function<void(int, int, TrieNode*)> walk = [&](int x, int y, TrieNode* node) {      
      if (x < 0 || x == m || y < 0 || y == n || board[y][x] == '#')
        return;      
      
      const char cur = board[y][x];
      TrieNode* next_node = node->nodes[cur - 'a'];
      
      // Pruning, only expend paths that are in the trie.
      if (!next_node) return;
      
      if (next_node->word) {
        ans.push_back(*next_node->word);
        next_node->word = nullptr;
      }

      board[y][x] = '#';
      walk(x + 1, y, next_node);
      walk(x - 1, y, next_node);
      walk(x, y + 1, next_node);
      walk(x, y - 1, next_node);
      board[y][x] = cur;
    };
    
    // Try all possible pathes.
    for (int i = 0 ; i < n; i++)
      for (int j = 0 ; j < m; j++)
        walk(j, i, &root);        
        
    return ans;
  }
};

The post 花花酱 LeetCode 212. Word Search II appeared first on Huahua's Tech Road.

LeetCode 1029 Two City Scheduling

Solution1: DP

dp[i][j] := min cost to put j people into city A for the first i people
dp[0][0] = 0
dp[i][0] = dp[i -1][0] + cost_b
dp[i][j] = min(dp[i – 1][j] + cost_b, dp[i – 1][j – 1] + cost_a)
ans := dp[n][n/2]

Time complexity: O(n^2)
Space complexity: O(n^2)

// Author: Huahua, running time: 8 ms
class Solution {
public:
  int twoCitySchedCost(vector<vector<int>>& costs) {
    int n = costs.size();
    vector<vector<int>> dp(n + 1, vector<int>(n + 1, INT_MAX / 2));
    dp[0][0] = 0;
    for (int i = 1; i <= n; ++i) {      
      dp[i][0] = dp[i - 1][0] + costs[i - 1][1];
      for (int j = 1; j <= i; ++j)
        dp[i][j] = min(dp[i - 1][j - 1] + costs[i - 1][0], 
                       dp[i - 1][j] + costs[i - 1][1]);
    }
    return dp[n][n / 2];
  }
};

Solution 2: Greedy

Sort by cost_a – cost_b

Choose the first n/2 people for A, rest for B

Time complexity: O(nlogn)
Space complexity: O(1)

// Author: Huahua, running time: 8 ms
class Solution {
public:
  int twoCitySchedCost(vector<vector<int>>& costs) {
    int n = costs.size();
    sort(begin(costs), end(costs), [](const auto& c1, const auto& c2){
      return c1[0] - c1[1] < c2[0] - c2[1];
    });
    int ans = 0;
    for (int i = 0; i < n; ++i)
      ans += i < n/2 ? costs[i][0] : costs[i][1];    
    return ans;
  }
};

1030. Matrix Cells in Distance Order

Solution: Sorting

Time complexity: O(RC*log(RC))
Space complexity: O(RC)

// Author: Huahua
class Solution {
public:
  vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {
    vector<vector<int>> ans;
    for (int i = 0; i < R; ++i)
      for (int j = 0; j < C; ++j)
        ans.push_back({i, j});
    std::sort(begin(ans), end(ans), [r0, c0](const vector<int>& a, const vector<int>& b){
      return (abs(a[0] - r0) + abs(a[1] - c0)) < (abs(b[0] - r0) + abs(b[1] - c0));
    });
    return ans;
  }
};

1031. Maximum Sum of Two Non-Overlapping Subarrays

Solution: Prefix sum

Time complexity: O(n^2)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
    const int n = A.size();
    vector<int> s(n + 1, 0);
    for (int i = 0; i < n; ++i)
      s[i + 1] = s[i] + A[i];
    int ans = 0;
    for (int i = 0; i <= n - L; ++i) {
      int ls = s[i + L] - s[i];
      int ms = max(maxSum(s, 0, i - M - 1, M), 
                   maxSum(s, i + L, n - M, M));
      ans = max(ans, ls + ms);      
    }
    return ans;
  }
private:
  int maxSum(const vector<int>& s, int start, int end, int l) {
    int ans = INT_MIN;    
    for (int i = start; i <= end; ++i)
      ans = max(ans, s[i + l] - s[i]);
    return ans;
  }
};

1032. Stream of Characters

Solution: Trie

Time complexity:

• build O(sum(len(w))
• query O(max(len(w))

Space complexity: O(sum(len(w))

// Author: Huahua, 320 ms, 95 MB
class TrieNode {
public:        
  ~TrieNode() {
    for (auto node : next_)
      delete node;
  }

  void reverse_build(const string& s, int i) {
    if (i == -1) {
      is_word_ = true;
      return;
    }
    const int idx = s[i] - 'a';
    if (!next_[idx]) next_[idx] = new TrieNode();
    next_[idx]->reverse_build(s, i - 1);
  }
  
  bool reverse_search(const string& s, int i) {
    if (i == -1 || is_word_) return is_word_;
    const int idx = s[i] - 'a';
    if (!next_[idx]) return false;
    return next_[idx]->reverse_search(s, i - 1);
  }

private:
  bool is_word_ = false;
  TrieNode* next_[26] = {0};
};

class StreamChecker {
public:
  StreamChecker(vector<string>& words) {
    root_ = std::make_unique<TrieNode>();
    for (const string& w : words)
      root_->reverse_build(w, w.length() - 1);
  }

  bool query(char letter) {
    s_ += letter;
    return root_->reverse_search(s_, s_.length() - 1);    
  }
  
private:
  string s_;
  unique_ptr<TrieNode> root_;
};

// Author: Huahua, running time: 133 ms
class StreamChecker {
  class TrieNode {
    public TrieNode() {
      isWord = false;
      next = new TrieNode[26];
    }
    public boolean isWord;
    public TrieNode next[];    
  }
  
  private TrieNode root;
  private StringBuilder sb;

  public StreamChecker(String[] words) {
    root = new TrieNode();
    sb = new StringBuilder();
    for (String word : words) {
      TrieNode node = root;
      char[] w = word.toCharArray();
      for (int i = w.length - 1; i >= 0; --i) {        
        int idx = w[i] - 'a';
        if (node.next[idx] == null) node.next[idx] = new TrieNode();
        node = node.next[idx];
      }
      node.isWord = true;
    }
  }

  public boolean query(char letter) {
    sb.append(letter);
    TrieNode node = root;
    for (int i = sb.length() - 1; i >= 0; --i) {      
      int idx = sb.charAt(i) - 'a';
      if (node.next[idx] == null) return false;
      if (node.next[idx].isWord) return true;
      node = node.next[idx];
    }
    return false;
  }  
}

The post 花花酱 LeetCode Weekly Contest 133 appeared first on Huahua's Tech Road.

https://leetcode.com/problems/replace-words/description/

In English, we have a concept called root, which can be followed by some other words to form another longer word – let’s call this word successor. For example, the root an, followed by other, which can form another word another.

Now, given a dictionary consisting of many roots and a sentence. You need to replace all the successor in the sentence with the root forming it. If a successor has many roots can form it, replace it with the root with the shortest length.

You need to output the sentence after the replacement.

Example 1:

Input: dict = ["cat", "bat", "rat"]
sentence = "the cattle was rattled by the battery"
Output: "the cat was rat by the bat"

Note:

1. The input will only have lower-case letters.
2. 1 <= dict words number <= 1000
3. 1 <= sentence words number <= 1000
4. 1 <= root length <= 100
5. 1 <= sentence words length <= 1000

Solution 1: HashTable

Time complexity: O(sum(w^2))

Space complexity: O(sum(l))

// Author: Huahua, Running time: 84 ms
class Solution {
public:
  string replaceWords(vector<string>& dict, string sentence) {
    unordered_set<string> d(begin(dict), end(dict));
    sentence.push_back(' ');
    string output;
    string word;
    bool found = false;
    for (char c : sentence) {
      if (c == ' ') {
        if (!output.empty()) output += ' ';
        output += word;
        word = "";
        found = false;
        continue;
      }
      if (found) continue;
      word += c;
      if (d.count(word)) {
        found = true;
      }
    }
    return output;
  }
};

Solution2: Trie

Time complexity: O(sum(l) + n)

Space complexity: O(sum(l) * 26)

// Author: Huahua, running time: 48 ms
class TrieNode {
public:
  TrieNode(): children(26), is_word(false) {}
  ~TrieNode() {
    for (int i = 0; i < 26; ++i)
      if (children[i]) {
        delete children[i];
        children[i] = nullptr;
      }
  }
  vector<TrieNode*> children;
  bool is_word;
};
class Solution {
public:
  string replaceWords(vector<string>& dict, string sentence) {    
    TrieNode root;
    for (const string& word : dict) {
      TrieNode* cur = &root;
      for (char c : word) {        
        if (!cur->children[c - 'a']) cur->children[c - 'a'] = new TrieNode();
        cur = cur->children[c - 'a'];
      }
      cur->is_word = true;
    }
    
    string ans;
    stringstream ss(sentence);
    string word;
    while (ss >> word) {      
      TrieNode* cur = &root;
      bool found = false;
      int len = 0;
      for (char c : word) {        
        cur = cur->children[c - 'a'];        
        if (!cur) break;
        ++len;
        if (cur->is_word) {
          found = true;
          break;
        }
      }      
      if (!ans.empty()) ans += ' ';      
      ans += found ? word.substr(0, len) : word;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 648. Replace Words appeared first on Huahua's Tech Road.

Problem:

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.

Idea:

Construct all possible filters

Solution1:

C++

Time complexity: O(NL^3 + QL)  where N is the number of words, L is the max length of the word, Q is the number of queries.

Space complexity: O(NL^3)

// Author: Huahua
// Runtime: 482 ms
class WordFilter {
public:
    WordFilter(const vector<string>& words) {
        int index = 0;
        for (const string& word : words) {
            int n = word.length();
            string prefix;
            for (int i = 0; i <= n; ++i) {
                if (i > 0) prefix += word[i - 1];
                string suffix;
                for (int j = n; j >= 0; --j) {                    
                    if (j != n) suffix = word[j] + suffix;
                    const string key = prefix + "_" + suffix;
                    filters_[key] = index;                    
                }                
            }
            ++index;
        }
    }
    
    int f(string prefix, string suffix) {
        const string key = prefix + "_" + suffix;
        auto it = filters_.find(key);
        if (it != filters_.end()) return it->second;
        return -1;
    }
private:
    unordered_map<string, int> filters_;
};

Version #2

// Author: Huahua
// Runtime: 499 ms
class WordFilter {
public:
    WordFilter(const vector<string>& words) {
        int index = 0;
        for (const string& word : words) {
            int n = word.length();
            vector<string> prefixes(n + 1, "");
            vector<string> suffixes(n + 1, "");
            for (int i = 0; i < n; ++i) {
                prefixes[i + 1] = prefixes[i] + word[i];
                suffixes[i + 1] = word[n - i - 1] + suffixes[i];
            }
            
            for (const string& prefix : prefixes)          
                for (const string& suffix : suffixes)                              
                    filters_[prefix + "_" + suffix] = index;            
            ++index;
        }        
    }
    
    int f(string prefix, string suffix) {
        const string key = prefix + "_" + suffix;
        auto it = filters_.find(key);
        if (it != filters_.end()) return it->second;
        return -1;
    }
private:
    unordered_map<string, int> filters_;
};

Solution 2:

C++ / Trie

Time complexity: O(NL^2 + QL)  where N is the number of words, L is the max length of the word, Q is the number of queries.

Space complexity: O(NL^2)

// Author: Huahua
// Runtime: 572 ms
class Trie {
public:
    /** Initialize your data structure here. */
    Trie(): root_(new TrieNode()) {}
    
    /** Inserts a word into the trie. */
    void insert(const string& word, int index) {
        TrieNode* p = root_.get();
        for (const char c : word) {            
            if (!p->children[c - 'a'])
                p->children[c - 'a'] = new TrieNode();
            p = p->children[c - 'a'];
            // Update index
            p->index = index;
        }
        p->is_word = true;
    }
    
    
    /** Returns the index of word that has the prefix. */
    int startsWith(const string& prefix) const {
        auto node = find(prefix);
        if (!node) return -1;
        return node->index;
    }
private:
    struct TrieNode {
        TrieNode():index(-1), is_word(false), children(27, nullptr){}
        
        ~TrieNode() {
            for (TrieNode* child : children)
                if (child) delete child;
        }
        
        int index;
        int is_word;
        vector<TrieNode*> children;
    };
    
    const TrieNode* find(const string& prefix) const {
        const TrieNode* p = root_.get();
        for (const char c : prefix) {
            p = p->children[c - 'a'];
            if (p == nullptr) break;
        }
        return p;
    }
    
    std::unique_ptr<TrieNode> root_;
};

class WordFilter {
public:
    WordFilter(vector<string> words) {        
        for (int i = 0; i < words.size(); ++i) {
            const string& w = words[i];            
            string key = "{" + w;
            trie_.insert(key, i);            
            for (int j = 0; j < w.size(); ++j) {
                key = w[w.size() - j - 1] + key;                
                trie_.insert(key, i);
            }
        }
    }
    
    int f(string prefix, string suffix) {        
        return trie_.startsWith(suffix + "{" + prefix);
    }
private:
    Trie trie_;
};

Related Problems:

• [解题报告] LeetCode 676. Implement Magic Dictionary
• [解题报告] LeetCode 208. Implement Trie (Prefix Tree)

The post 花花酱 LeetCode 745. Prefix and Suffix Search appeared first on Huahua's Tech Road.

Given a list of strings words representing an English Dictionary, find the longest word in words that can be built one character at a time by other words in words. If there is more than one possible answer, return the longest word with the smallest lexicographical order.

If there is no answer, return the empty string.

Example 1:

Input: 
words = ["w","wo","wor","worl", "world"]
Output: "world"
Explanation: 
The word "world" can be built one character at a time by "w", "wo", "wor", and "worl".

Example 2:

Input: 
words = ["a", "banana", "app", "appl", "ap", "apply", "apple"]
Output: "apple"
Explanation: 
Both "apply" and "apple" can be built from other words in the dictionary. 
However, "apple" is lexicographically smaller than "apply".

Note:

• All the strings in the input will only contain lowercase letters.
• The length of words will be in the range [1, 1000].
• The length of words[i] will be in the range [1, 30].

Idea:

Brute force

Trie

Solution:

C++

// Author: Huahua
// Runtime: 39 ms (better than 97.85%)
class Solution {
public:
    string longestWord(vector<string>& words) {
        string best;        
        unordered_set<string> dict(words.begin(), words.end());
        
        for (const string& word : words) {
            if (word.length() < best.length() 
             || (word.length() == best.length() && word > best)) 
                continue;
            string prefix;
            bool valid = true;
            for (int i = 0; i < word.length() - 1 && valid; ++i) {
                prefix += word[i];
                if (!dict.count(prefix)) valid = false;
            }
            if (valid) best = word;
        }
        
        return best;
    }
};

// Author: Huahua
// Runtime: 46 ms
class Solution {
public:
    string longestWord(vector<string>& words) {
        // Sort by length DESC, if there is a tie, sort by lexcial order.
        std::sort(words.begin(), words.end(), 
                  [](const string& w1, const string& w2){
                    if (w1.length() != w2.length()) 
                        return w1.length() > w2.length();
                    return w1 < w2;
                  });
        
        unordered_set<string> dict(words.begin(), words.end());
        
        for (const string& word : words) {
            string prefix;
            bool valid = true;
            for (int i = 0; i < word.length() - 1 && valid; ++i) {
                prefix += word[i];
                if (!dict.count(prefix)) valid = false;
            }
            if (valid) return word;
        }
        
        return "";
    }
};

Trie + Sorting

// Author: Huahua
// Runtime: 49 ms
class Trie {
public:
    Trie(): root_(new TrieNode()) {}
    
    void insert(const string& word) {
        TrieNode* p = root_.get();
        for (const char c : word) {
            if (!p->children[c - 'a'])
                p->children[c - 'a'] = new TrieNode();
            p = p->children[c - 'a'];
        }
        p->is_word = true;
    }
    
    bool hasAllPrefixes(const string& word) {
        const TrieNode* p = root_.get();
        for (const char c : word) {
            if (!p->children[c - 'a']) return false;
            p = p->children[c - 'a'];
            if (!p->is_word) return false;
        }
        return true;
    }    
private:
    struct TrieNode {
        TrieNode():is_word(false), children(26, nullptr){}
        
        ~TrieNode() {
            for (auto node : children)
                delete node;
        }
        
        bool is_word;
        vector<TrieNode*> children;
    };
    
    std::unique_ptr<TrieNode> root_;
};

class Solution {
public:
    string longestWord(vector<string>& words) {
        std::sort(words.begin(), words.end(), 
          [](const string& w1, const string& w2){
            if (w1.length() != w2.length()) 
                return w1.length() > w2.length();
            return w1 < w2;
          });
            
        Trie trie;
        for (const string& word : words)
            trie.insert(word);
                
        for (const string& word : words)
            if (trie.hasAllPrefixes(word)) return word;  
        
        return "";
    }
};

Trie + No sorting

// Author: Huahua
// Runtime: 56 ms
class Trie {
public:
    Trie(): root_(new TrieNode()) {}
    
    void insert(const string& word) {
        TrieNode* p = root_.get();
        for (const char c : word) {
            if (!p->children[c - 'a'])
                p->children[c - 'a'] = new TrieNode();
            p = p->children[c - 'a'];
        }
        p->is_word = true;
    }
    
    bool hasAllPrefixes(const string& word) {
        const TrieNode* p = root_.get();
        for (const char c : word) {
            if (!p->children[c - 'a']) return false;
            p = p->children[c - 'a'];
            if (!p->is_word) return false;
        }
        return true;
    }    
private:
    struct TrieNode {
        TrieNode():is_word(false), children(26, nullptr){}
        
        ~TrieNode() {
            for (auto node : children)
                delete node;
        }
        
        bool is_word;
        vector<TrieNode*> children;
    };
    
    std::unique_ptr<TrieNode> root_;
};

class Solution {
public:
    string longestWord(vector<string>& words) {
        Trie trie;
        for (const string& word : words)
            trie.insert(word);
        
        string best;
        for (const string& word : words) {
            if (word.length() < best.length() 
            || (word.length() == best.length() && word > best))
                continue;
            if (trie.hasAllPrefixes(word))
                best = word;
        }
        
        return best;
    }
};

The post 花花酱 LeetCode 720. Longest Word in Dictionary appeared first on Huahua's Tech Road.

Problem:

Implement a trie with insert, search, and startsWith methods.

Note:
You may assume that all inputs are consist of lowercase letters a-z.

Idea:

Tree/children array

Solution:

C++ / Array

// Author: Huahua 
// Running time: 99 ms
class Trie {
public:
    /** Initialize your data structure here. */
    Trie(): root_(new TrieNode()) {}
    
    /** Inserts a word into the trie. */
    void insert(const string& word) {
        TrieNode* p = root_.get();
        for (const char c : word) {
            if (!p->children[c - 'a'])
                p->children[c - 'a'] = new TrieNode();
            p = p->children[c - 'a'];
        }
        p->is_word = true;
    }
    
    /** Returns if the word is in the trie. */
    bool search(const string& word) const {
        const TrieNode* p = find(word);
        return p && p->is_word;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(const string& prefix) const {
        return find(prefix) != nullptr;
    }
private:
    struct TrieNode {
        TrieNode():is_word(false), children(26, nullptr){}
        
        ~TrieNode() {
            for (TrieNode* child : children)
                if (child) delete child;
        }
               
        bool is_word;
        vector<TrieNode*> children;
    };
    
    const TrieNode* find(const string& prefix) const {
        const TrieNode* p = root_.get();
        for (const char c : prefix) {
            p = p->children[c - 'a'];
            if (p == nullptr) break;
        }
        return p;
    }
    
    std::unique_ptr<TrieNode> root_;
};

C++ / hashmap

// Author: Huahua
// Running time: 98 ms
class Trie {
public:
    /** Initialize your data structure here. */
    Trie(): root_(new TrieNode()) {}
    
    /** Inserts a word into the trie. */
    void insert(const string& word) {
        TrieNode* p = root_.get();
        for (const char c : word) {
            if (!p->children.count(c))
                p->children[c] = new TrieNode();
            p = p->children[c];
        }
        p->is_word = true;
    }
    
    /** Returns if the word is in the trie. */
    bool search(const string& word) const {
        const TrieNode* p = find(word);
        return p && p->is_word;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(const string& prefix) const {
        return find(prefix) != nullptr;
    }
private:
    struct TrieNode {
        TrieNode():is_word(false){}
        
        ~TrieNode() {
            for (auto& kv : children)
                if (kv.second) delete kv.second;
        }
        
        bool is_word;
        unordered_map<char, TrieNode*> children;
    };
    
    const TrieNode* find(const string& prefix) const {
        const TrieNode* p = root_.get();
        for (const char c : prefix) {
            if (!p->children.count(c)) return nullptr;
            p = p->children.at(c);
        }
        return p;
    }
    
    std::unique_ptr<TrieNode> root_;
};

Java

// Author: Huahua
// Running time: 184 ms
class Trie {
    class TrieNode {
        public TrieNode() {
            children = new TrieNode[26];
            is_word = false;
        }
        public boolean is_word;
        public TrieNode[] children;
    }
    
    private TrieNode root;
    
    /** Initialize your data structure here. */
    public Trie() {
        root = new TrieNode();
    }
    
    /** Inserts a word into the trie. */
    public void insert(String word) {
        TrieNode p = root;
        for (int i = 0; i < word.length(); i++) {
            int index = (int)(word.charAt(i) - 'a');
            if (p.children[index] == null)
                p.children[index] = new TrieNode();
            p = p.children[index];
        }
        p.is_word = true;
    }
    
    /** Returns if the word is in the trie. */
    public boolean search(String word) {
        TrieNode node = find(word);
        return node != null && node.is_word;
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    public boolean startsWith(String prefix) {
        TrieNode node = find(prefix);
        return node != null;
    }
    
    private TrieNode find(String prefix) {
        TrieNode p = root;
        for(int i = 0; i < prefix.length(); i++) {
            int index = (int)(prefix.charAt(i) - 'a');
            if (p.children[index] == null) return null;
            p = p.children[index];
        }
        return p;
    }
}

Python 1:

"""
Author: Huahua
Running time: 469 ms
"""
class Trie(object):
    class TrieNode(object):
        def __init__(self):
            self.is_word = False
            self.children = [None] * 26
        
    def __init__(self):
        self.root = Trie.TrieNode()
        

    def insert(self, word):
        p = self.root
        for c in word:
            index = ord(c) - ord('a')
            if not p.children[index]: 
                p.children[index] = Trie.TrieNode()
            p = p.children[index]
        p.is_word = True

    def search(self, word):
        node = self.find(word)
        return node is not None and node.is_word
        

    def startsWith(self, prefix):
        return self.find(prefix) is not None
    
    def find(self, prefix):
        p = self.root
        for c in prefix:
            index = ord(c) - ord('a')
            if not p.children[index]: return None
            p = p.children[index]
        return p

Python 2:

"""
Author: Huahua
Running time: 212 ms
"""
class Trie(object):            
    def __init__(self):
        self.root = {}
        

    def insert(self, word):
        p = self.root
        for c in word:            
            if c not in p: 
                p[c] = {}
            p = p[c]
        p['#'] = True

    def search(self, word):
        node = self.find(word)
        return node is not None and '#' in node
        

    def startsWith(self, prefix):
        return self.find(prefix) is not None
    
    def find(self, prefix):
        p = self.root
        for c in prefix:            
            if c not in p: return None
            p = p[c]
        return p

The post 花花酱 LeetCode 208. Implement Trie (Prefix Tree) appeared first on Huahua's Tech Road.

https://leetcode.com/problems/map-sum-pairs/description/

Problem:

Implement a MapSum class with insert, and sum methods.

For the method insert, you’ll be given a pair of (string, integer). The string represents the key and the integer represents the value. If the key already existed, then the original key-value pair will be overridden to the new one.

For the method sum, you’ll be given a string representing the prefix, and you need to return the sum of all the pairs’ value whose key starts with the prefix.

Example 1:

Input: insert("apple", 3), Output: Null
Input: sum("ap"), Output: 3
Input: insert("app", 2), Output: Null
Input: sum("ap"), Output: 5

Idea:

Prefix tree

Solution 1

// Author: Huahua
// Running time: 3 ms
class MapSum {
public:
    /** Initialize your data structure here. */
    MapSum() {}
    
    void insert(const string& key, int val) {
        int inc = val;
        if (vals_.count(key)) {
            inc -= vals_[key];
        }
        vals_[key] = val;
        for (int i = 1; i <= key.length(); ++i)
            sums_[key.substr(0,i)] += inc;
    }
    
    int sum(const string& prefix) {
        return sums_[prefix];
    }
private:
    unordered_map<string, int> vals_;
    unordered_map<string, int> sums_;    
};

Solution 2:

class MapSum {
public:
    /** Initialize your data structure here. */
    MapSum() {}
    
    void insert(string key, int val) {
        int inc = val - vals_[key];
        Trie* p = &root;
        for (const char c : key) {
            if (!p->children[c])
                p->children[c] = new Trie();
            p->children[c]->sum += inc;
            p = p->children[c];
        }
        vals_[key] = val;
    }
    
    int sum(string prefix) {
        Trie* p = &root;
        for (const char c : prefix) {
            if (!p->children[c]) return 0;
            p = p->children[c];
        }        
        return p->sum;
    }
private:
    struct Trie {
        Trie():children(128, nullptr), sum(0){}
        ~Trie() {
            for (auto child : children)
                if (child) delete child;
            children.clear();
        }
        vector<Trie*> children;
        int sum;        
    };
    
    Trie root; // dummy root
    unordered_map<string, int> vals_; // key -> val
};

with std::unique_ptr

// Author: Huahua
// Running time: 5 ms
class MapSum {
public:
    /** Initialize your data structure here. */
    MapSum(): root_(new Trie()) {}
  
    void insert(string key, int val) {      
      int inc = val - vals_[key];
      Trie* p = root_.get();
      for (const char c : key) {
        if (!p->children[c])
          p->children[c] = new Trie();
        p->children[c]->sum += inc;
        p = p->children[c];
      }
      vals_[key] = val;
    }
    
    int sum(string prefix) {
      Trie* p = root_.get();
      for (const char c : prefix) {
        if (!p->children[c]) return 0;
        p = p->children[c];
      }

      return p->sum;        
    }
private:
    struct Trie {
        Trie():children(128, nullptr), sum(0){}
        ~Trie() {
          for (auto child : children)
            if (child) {
              delete child;
              child = nullptr;
            }
          children.clear();
        }
        vector<Trie*> children;
        int sum;        
    };
    
    std::unique_ptr<Trie> root_;
    unordered_map<string, int> vals_; // key -> val
};

The post 花花酱 LeetCode 677. Map Sum Pairs appeared first on Huahua's Tech Road.

Problem:

Input: buildDict(["hello", "leetcode"]), Output: Null
Input: search("hello"), Output: False
Input: search("hhllo"), Output: True
Input: search("hell"), Output: False
Input: search("leetcoded"), Output: False

// Author: Huahua
class MagicDictionary {
public:
    /** Initialize your data structure here. */
    MagicDictionary() {
        dict_.clear();
    }
    
    /** Build a dictionary through a list of words */
    void buildDict(vector<string> dict) {
        for(string& word: dict) {
            for(int i = 0; i < word.length(); ++i) {
                char c = word[i];
                word[i] = '*';
                dict_[word].insert(c);
                word[i] = c;
            }
        }
    }
    
    /** Returns if there is any word in the trie that equals to the given word after modifying exactly one character */
    bool search(string word) {
        for(int i = 0; i < word.length(); ++i) {
            char c = word[i];
            word[i] = '*';
            if (dict_.count(word)) {
                const auto& char_set = dict_[word];
                if (!char_set.count(c) || char_set.size() > 1)
                    return true;
            }
            word[i] = c;
        }
        return false;
    }
private:
    unordered_map<string, unordered_set<char>> dict_;
};

/**
 * Your MagicDictionary object will be instantiated and called as such:
 * MagicDictionary obj = new MagicDictionary();
 * obj.buildDict(dict);
 * bool param_2 = obj.search(word);
 */

Java / Trie

class MagicDictionary {
    private Trie root;    
    
    public MagicDictionary() {
        root = new Trie();
    } 
    
    public void buildDict(String[] dict) {
        for (String word : dict) {
            Trie curr = root;
            for (char c : word.toCharArray()) {                
                int index = c - 'a';
                if (curr.children[index] == null)
                    curr.children[index] = new Trie();
                curr = curr.children[index];
            }
            curr.ends = true;
        }
    }  
    
    public boolean search(String word) {
        char[] s = word.toCharArray();
        for(int i = 0; i < s.length; i++) {
            for (char c = 'a'; c <= 'z'; ++c) {
                if (s[i] == c) continue;
                char tmp = s[i];
                s[i] = c;
                if (contains(s)) return true;
                s[i] = tmp;
            }
        }
        return false;
    }
    
    private boolean contains(char[] word) {        
        Trie curr = root;
        for (int i = 0; i < word.length; ++i) {
            curr = curr.children[word[i] - 'a'];
            if (curr == null) return false;            
        }
        return curr.ends;
    }
    
    class Trie {
        private boolean ends;
        private Trie[] children;
        public Trie() {
            children = new Trie[26];
            ends = false;
        }
    }
}

Java / Trie v2

class MagicDictionary {
    private Trie root;    
    
    public MagicDictionary() {
        root = new Trie();
    } 
    
    public void buildDict(String[] dict) {
        for (String word : dict) {
            Trie curr = root;
            for (char c : word.toCharArray()) {                
                int index = c - 'a';
                if (curr.children[index] == null)
                    curr.children[index] = new Trie();
                curr = curr.children[index];
            }
            curr.ends = true;
        }
    }  
    
    public boolean search(String word) {
        char[] s = word.toCharArray();
        Trie prefix = root;
        for(int i = 0; i < s.length; i++) {
            for (char c = 'a'; c <= 'z'; ++c) {
                if (s[i] == c) continue;
                char tmp = s[i];
                s[i] = c;
                if (contains(s, prefix, i)) return true;
                s[i] = tmp;                
            }
            prefix = prefix.children[s[i] - 'a'];
            if (prefix == null) return false;
        }
        return false;
    }
    
    private boolean contains(char[] word, Trie prefix, int s) {        
        Trie curr = prefix;
        for (int i = s; i < word.length; ++i) {
            curr = curr.children[word[i] - 'a'];
            if (curr == null) return false;
        }
        return curr.ends;
    }
    
    class Trie {
        private boolean ends;
        private Trie[] children;
        public Trie() {
            children = new Trie[26];
            ends = false;
        }
    }
}

The post 花花酱 LeetCode 676. Implement Magic Dictionary appeared first on Huahua's Tech Road.