submissions until 2019/12/24

Author: IdeoG

ok_add_and_search_word.py

@@ -0,0 +1,99 @@
+"""
+211. Add and Search Word - Data structure design
+Medium
+
+Design a data structure that supports the following two operations:
+
+void addWord(word)
+bool search(word)
+search(word) can search a literal word or a regular expression string containing only letters a-z or `.`.
+A `.` means it can represent any one letter.
+
+Note:
+You may assume that all words are consist of lowercase letters a-z.
+
+Details
+Runtime: 276 ms, faster than 82.23% of Python3 online submissions for Add and Search Word - Data structure design.
+Memory Usage: 23.2 MB, less than 91.30% of Python3 online submissions for Add and Search Word - Data structure design.
+"""
+
+
+class WordDictionary:
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.trie = {}
+
+    def addWord(self, word: str) -> None:
+        """
+        Adds a word into the data structure.
+        """
+        node = self.trie
+        for ch in word:
+            if ch not in node:
+                node[ch] = {}
+            node = node[ch]
+        node['#'] = None
+
+    def search(self, word: str) -> bool:
+        """
+        Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter.
+        """
+        node = self.trie
+        return self.__search_dfs(word, 0, node) is True
+
+    def __search_bfs(self, word: str, trie) -> bool:
+        """ 332 - 360 ms """
+        q = [(trie, 0)]
+        while q:
+            node, i = q.pop(0)
+
+            if i == len(word):
+                if '#' in node:
+                    return True
+                else:
+                    continue
+
+            if word[i] == '.':
+                for k in node.keys():
+                    if k != '#':
+                        q.append((node[k], i + 1))
+            elif word[i] in node:
+                q.append((node[word[i]], i + 1))
+
+        return False
+
+    def __search_dfs(self, word, w_idx, trie):
+        """ 272 ms """
+        if w_idx == len(word):
+            return '#' in trie
+
+        if word[w_idx] == '.':
+            for k in trie:
+                if k != '#' and self.__search_dfs(word, w_idx + 1, trie[k]):
+                    return True
+        elif word[w_idx] in trie and self.__search_dfs(word, w_idx + 1, trie[word[w_idx]]):
+            return True
+
+
+def _main():
+    wd = WordDictionary()
+    wd.addWord('bad')
+    wd.addWord('dad')
+    wd.addWord('mad')
+    assert not wd.search('pad')
+    assert wd.search('bad')
+    assert wd.search('.ad')
+    assert wd.search('b.d')
+    assert wd.search('b..')
+    assert not wd.search('b...')
+    assert wd.search('...')
+    assert not wd.search('.at')
+    wd.addWord('bat')
+    assert wd.search('.at')
+
+
+if __name__ == '__main__':
+    _main()

ok_implement_trie.py

@@ -0,0 +1,53 @@
+"""208. Implement Trie (Prefix Tree)
+Medium
+
+Implement a trie with insert, search, and startsWith methods.
+
+Note:
+You may assume that all inputs are consist of lowercase letters a-z.
+All inputs are guaranteed to be non-empty strings.
+
+Details
+Runtime: 120 ms, faster than 98.95% of Python3 online submissions for Implement Trie (Prefix Tree).
+Memory Usage: 25.9 MB, less than 66.67% of Python3 online submissions for Implement Trie (Prefix Tree).
+"""
+
+
+class Trie:
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.root = {}
+
+    def insert(self, word: str) -> None:
+        """
+        Inserts a word into the trie.
+        """
+        node = self.root
+        for ch in word:
+            if ch not in node:
+                node[ch] = {}
+            node = node[ch]
+
+        node['#'] = None
+
+    def search(self, word: str) -> bool:
+        """
+        Returns if the word is in the trie.
+        """
+        node = self.root
+        for ch in word:
+            if ch not in node:
+                return False
+            node = node[ch]
+        return '#' in node
+
+    def startsWith(self, word: str) -> bool:
+        node = self.root
+        for ch in word:
+            if ch not in node:
+                return False
+            node = node[ch]
+        return True

ok_word_search_2.py

@@ -0,0 +1,95 @@
+"""
+212. Word Search II
+Hard
+
+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:
+All inputs are consist of lowercase letters a-z.
+The values of words are distinct.
+"""
+
+"""
+Naive approach:
+1. Build Trie
+2. iter over row, col
+    2.1.    use dfs to find word
+    
+Details 
+Runtime: 292 ms, faster than 80.15% of Python3 online submissions for Word Search II.
+Memory Usage: 27.1 MB, less than 100.00% of Python3 online submissions for Word Search II.
+"""
+from typing import List
+
+
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        trie = {}
+
+        for word in words:
+            node = trie
+            for ch in word:
+                if ch not in node:
+                    node[ch] = {}
+                node = node[ch]
+            node['#'] = None
+
+        n, m = len(board), len(board[0])
+        result = set()
+
+        def dfs_search(i, j, node, path):
+            if not (0 <= i < n and 0 <= j < m) or board[i][j] == '*' or board[i][j] not in node:
+                return
+
+            ch = board[i][j]
+            board[i][j] = '*'
+            path.append(ch)
+
+            if '#' in node[ch]:
+                result.add(''.join(path))
+
+            dfs_search(i - 1, j, node[ch], path)
+            dfs_search(i + 1, j, node[ch], path)
+            dfs_search(i, j - 1, node[ch], path)
+            dfs_search(i, j + 1, node[ch], path)
+
+            path.pop()
+            board[i][j] = ch
+
+        for i in range(n):
+            for j in range(m):
+                dfs_search(i, j, trie, [])
+
+        return list(result)
+
+
+def _main():
+    board = [
+        ['o', 'a', 'a', 'n'],
+        ['e', 't', 'a', 'e'],
+        ['i', 'h', 'k', 'r'],
+        ['i', 'f', 'l', 'v']
+    ]
+    words = ["oath", "pea", "eat", "rain"]
+    assert {"eat", "oath"} == set(Solution().findWords(board, words))
+
+    board = [["a", "a"]]
+    words = ["a"]
+    assert ['a'] == Solution().findWords(board, words)
+
+
+if __name__ == '__main__':
+    _main()