Leetcode-211. Add and Search Word - Data structure design

一、题目描述

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.

Example:

addWord("bad")
addWord("dad")
addWord("mad")
search("pad") -> false
search("bad") -> true
search(".ad") -> true
search("b..") -> true

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

二、解法，这个题目我用普通方法实现，结果超时了

　　

class Word:
	def __init__(self, s):
		self.s = s

	def __eq__(self, other):
		if isinstance(other, Word):
			if not self.s or not other.s:
				return self.s == other.s
			if len(self.s) != len(other.s):
				return False
			for i in range(len(self.s)):
				if self.s[i] != other.s[i] and self.s[i] != '.' and other.s[i] != '.':
					return False
			return True
			
	def __str__(self):
		return self.s
		
	def __hash__(self):
		return hash(str(self))

class WordDictionary:

	def __init__(self):
		"""
		Initialize your data structure here.
		"""
		self.m = {}
		

	def addWord(self, word):
		"""
		Adds a word into the data structure.
		:type word: str
		:rtype: void
		"""
		key = Word(word)
		if key in self.m:
			self.m[key] += 1
		else:
			self.m[key] = 1

	def search(self, word):
		"""
		Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter.
		:type word: str
		:rtype: bool
		"""
		key = Word(word)
		if key in self.m:
			return True
		
		for k in self.m:
			if k == key:
				return True
				
		return False
        

　　这个题目的本质是字典树，使用字典树才不会超时

class WordDictionary:
	
	class TrieNode:
		def __init__(self):
			self.isword = False
			self.child = [None for i in range(26)]

	def __init__(self):
		"""
		Initialize your data structure here.
		"""
		self.root = WordDictionary.TrieNode()
		

	def addWord(self, word):
		"""
		Adds a word into the data structure.
		:type word: str
		:rtype: void
		"""
		p = self.root
		for c in word:
			i = ord(c) - ord('a')
			if not p.child[i]:
				p.child[i] = WordDictionary.TrieNode()
			p = p.child[i]
		p.isword = True

	def search(self, word):
		"""
		Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter.
		:type word: str
		:rtype: bool
		"""
		return self.searchNode(word, self.root, 0)
		
	def searchNode(self, word, node, i):
		if i == len(word):
			return node.isword
		if word[i] == '.':
			for a in node.child:
				if a and self.searchNode(word, a, i+1):
					return True
			return False
		else:
			index = ord(word[i]) - ord('a')
			return node.child[index] != None and self.searchNode(word, node.child[index], i+1)

　　注意python和C语言的不同

　

def hello():
	x = None
	return (x and False) == None
	
def hello2():
	x = None
	return (x and False)

　　输出

True

None