no message

Author: Chris Wu

README.md

@@ -1,5 +1,5 @@
 # Leetcode Python Solution
-1. This is my Python (2.7) solution on Leetcode. The question is at `problems/the-file-name/`. For example, `merge-sorted-array.py`'s question is at `https://leetcode.com/problems/merge-sorted-array/`.
+1. This is my Python (2.7) Leetcode solution. The question is at `problems/the-file-name/`. For example, `merge-sorted-array.py`'s question is at `https://leetcode.com/problems/merge-sorted-array/`.
 
 2. I really take time tried to make the best solution or explaination. 
 Because I wanted to help others like me. 

problems/word-ladder.py

@@ -0,0 +1,97 @@
+"""
+This problem is better using BFS. Because we need to find the shortest step.
+Using DFS, we may eventually find the `endWord` but not the shortest path.
+
+First, build a memo so that we can find the related word without going through a~z every time we pop out a new word from queue.
+So for example
+```
+wordList = ["hot","dot","dog","lot","log","cog"]
+
+memo = {
+    'lo#': ['lot', 'log'],
+    'l#t': ['lot'],
+    '#ot': ['hot', 'dot', 'lot'],
+    'h#t': ['hot'],
+    'do#': ['dot', 'dog'],
+    'l#g': ['log'],
+    'co#': ['cog'],
+    '#og': ['dog', 'log', 'cog'],
+    'd#g': ['dog'],
+    'd#t': ['dot'],
+    'c#g': ['cog'],
+    'ho#': ['hot']
+}
+```
+
+Second build a queue to BFS from `beginWord` to `endWord`.
+Everytime we pop a word we first check if it is visited.
+Then check if it is `endWord`, if true, return the steps.
+If not, put all the neighbor to the queue.
+
+If the queue ended and we did not find the `endWord`, return 0.
+
+The time complexity is O(W*C), W is the word count, C is the character count in each word.
+The space complexity is also O(W*C).
+"""
+class Solution(object):
+    def ladderLength(self, beginWord, endWord, wordList):
+        memo = collections.defaultdict(list)
+        for word in wordList:
+            for i in xrange(len(word)):
+                memo[word[:i]+'#'+word[i+1:]].append(word)
+
+        seen = set()
+        q = collections.deque([(beginWord, 1)])
+        while q:
+            word, steps = q.popleft()
+            if word==endWord: return steps
+            seen.add(word)
+
+            for i in xrange(len(word)):
+                for next_word in memo[word[:i]+'#'+word[i+1:]]:
+                    if next_word not in seen:
+                        q.append((next_word, steps+1))
+        return 0
+
+"""
+When comparing to other solution, I made some changes.
+Which is the timing of adding the word to the `visited` hash-set.
+I think by adding the word to the hash-set in the for loop, makes the queue smaller, so it would be slightly faster.
+But the time complexity is totally the same.
+"""
+class Solution(object):
+    def ladderLength(self, beginWord, endWord, wordList):
+        memo = collections.defaultdict(list)
+        for word in wordList:
+            for i in xrange(len(word)):
+                memo[word[:i]+'#'+word[i+1:]].append(word)
+
+        seen = set()
+        q = collections.deque([(beginWord, 1)])
+        while q:
+            word, steps = q.popleft()
+            if word==endWord: return steps
+
+            for i in xrange(len(word)):
+                for next_word in memo[word[:i]+'#'+word[i+1:]]:
+                    if next_word not in seen:
+                        q.append((next_word, steps+1))
+                        seen.add(next_word)
+        return 0
+
+class Solution(object):
+    def ladderLength(self, beginWord, endWord, wordList):
+        wordList = set(wordList)
+        seen = set()
+        q = collections.deque([(beginWord, 1)])
+        while q:
+            word, steps = q.popleft()
+            if word==endWord: return steps
+
+            for i in xrange(len(word)):
+                for alphabet in 'abcdefghijklmnopqrstuvwxyz':
+                    next_word = word[:i]+alphabet+word[i+1:]
+                    if next_word not in seen and next_word in wordList:
+                        q.append((next_word, steps+1))
+                        seen.add(next_word)
+        return 0

problems/word-search-ii.py

@@ -0,0 +1,50 @@
+# TLE
+class Solution(object):
+    def findWords(self, board, words):
+        def getNeighbor(i, j):
+            opt = []
+            if i+1<M: opt.append((i+1, j))
+            if j+1<N: opt.append((i, j+1))
+            if i-1>=0: opt.append((i-1, j))
+            if j-1>=0: opt.append((i, j-1))
+            return opt
+
+        def dfs(i, j, l, word):
+            if word in found: return
+            if board[i][j]!=word[l]: return
+
+            if l==len(word)-1 and board[i][j]==word[l]:
+                opt.append(word)
+                found.add(word)
+                return
+
+            char = board[i][j]
+            board[i][j] = '#'
+
+            for ni, nj in getNeighbor(i, j):
+                dfs(ni, nj, l+1, word)
+
+            board[i][j] = char
+
+        opt = []
+        M = len(board)
+        N = len(board[0])
+        found = set()
+
+        for i in xrange(M):
+            for j in xrange(N):
+                for word in words:
+                    if word not in found:
+                        dfs(i, j, 0, word)
+        return opt
+
+
+board = [
+  ['o','a','a','n'],
+  ['e','t','a','e'],
+  ['i','h','k','r'],
+  ['i','f','l','v']
+]
+words = ["oath","pea","eat","rain"]
+
+print Solution().findWords(board, words)