no message

Author: Chris Wu

README.md

@@ -8,7 +8,7 @@ https://github.com/wuduhren/leetcode-python
 
 
 # Similar Problems
-I found it make sense to do similar problems together, so that we can recognize the problem faster when we encounter a new one.
+I found it make sense to do similar problems together, so that we can recognize the problem faster when we encounter a new one. My suggestion is to skip the HARD problems when you first go through these list.
 
 ### Two Pointers
 |  Id | Name | Difficulty | Comments |
@@ -36,7 +36,7 @@ I found it make sense to do similar problems together, so that we can recognize
 |  46 | [Permutations](https://leetcode.com/problems/permutations/ "Permutations") | ★★ | [47](https://leetcode.com/problems/permutations-ii/ "47") | [784](https://leetcode.com/problems/letter-case-permutation/ "784") | [943](https://leetcode.com/problems/find-the-shortest-superstring "943") | [996](https://leetcode.com/problems/number-of-squareful-arrays/ "996") |  |  | Permutation |
 |  22 | [Generate Parentheses](https://leetcode.com/problems/generate-parentheses/ "Generate Parentheses") | ★★★ | [301](https://leetcode.com/problems/remove-invalid-parentheses/ "301") |  |  |  |  |  | DFS |
 |  37 | [Sudoku Solver](https://leetcode.com/problems/sudoku-solver "Sudoku Solver") | ★★★ | [51](https://leetcode.com/problems/n-queens "51") | [52](https://leetcode.com/problems/n-queens-ii "52") |  |  |  |  | DFS |
-|  79 | [Word Search](https://leetcode.com/problems/word-search/ "Word Search") | ★★★ | [212](https://leetcode.com/problems/word-search-ii/submissions/ "212") |  |  |  |  |  | DFS |
+|  79 | [Word Search](https://leetcode.com/problems/word-search/ "Word Search") | ★★★ | [212](https://leetcode.com/problems/word-search-ii/ "212") |  |  |  |  |  | DFS |
 |  127 | [Word Ladder](https://leetcode.com/problems/word-ladder/ "Word Ladder") | ★★★★ | [126](https://leetcode.com/problems/word-ladder-ii/ "126") | [752](https://leetcode.com/problems/open-the-lock/ "752") |  |  |  |  | BFS |
 |  542 | [01 Matrix](https://leetcode.com/problems/01-matrix/ "01 Matrix") | ★★★ | [675](https://leetcode.com/problems/cut-off-trees-for-golf-event/ "675") | [934](https://leetcode.com/problems/shortest-bridge/ "934") |  |  |  |  | BFS |
 |  698 | [Partition to K Equal Sum Subsets](https://leetcode.com/problems/partition-to-k-equal-sum-subsets "Partition to K Equal Sum Subsets") | ★★★ | [93](https://leetcode.com/problems/restore-ip-addresses/ "93") | [131](https://leetcode.com/problems/palindrome-partitioning/ "131") | [241](https://leetcode.com/problems/different-ways-to-add-parentheses/ "241") | [282](https://leetcode.com/problems/expression-add-operators/ "282") | [842](https://leetcode.com/problems/split-array-into-fibonacci-sequence/ "842") |  | Partition |

problems/generate-parentheses.py

@@ -0,0 +1,22 @@
+"""
+If we need `N` pairs of parentheses, we need to use `N` open parenthesis (`open_remain`) and `N` close parenthesis (`close_remain`).
+We use `dfs()` to explore all kinds of possiblities.
+`open_count` keeps track of how many open parenthesis is in the `path` now. Because number of close parenthesis may not exceed open parenthesis in any given point.
+
+The time complexity is O(2^N), since we can roughly see every position has two options, open or close.
+The space complexity is O(2^N), too. And the recuresion level is O(N).
+"""
+class Solution(object):
+    def generateParenthesis(self, N):
+        def dfs(path, open_count, open_remain, close_remain):
+            if open_remain==0 and close_remain==0:
+                opt.append(path)
+                return
+            if open_count>0 and close_remain>0:
+                dfs(path+')', open_count-1, open_remain, close_remain-1)
+            if open_remain>0:
+                dfs(path+'(', open_count+1, open_remain-1, close_remain)
+
+        opt = []
+        dfs('', 0, N, N)
+        return opt

problems/letter-case-permutation.py

@@ -0,0 +1,24 @@
+"""
+For each character in the `S` (if it is not a number), it has 2 possibilities, upper or lower.
+So starting from an empty string
+We explore all the possibilities for the character at index i is upper or lower.
+
+The time complexity is `O(2^N)`.
+The space took `O(2^N), too. And the recursion level has N level.
+"""
+class Solution(object):
+    def letterCasePermutation(self, S):
+        def dfs(path, i):
+            if i>=len(S):
+                opt.append(path)
+                return
+            if S[i] not in num_char:
+                dfs(path+S[i].upper(), i+1)
+                dfs(path+S[i].lower(), i+1)
+            else:
+                dfs(path+S[i], i+1)
+
+        num_char = set(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])
+        opt = []
+        dfs('', 0)
+        return opt

problems/permutations-ii.py

@@ -0,0 +1,26 @@
+"""
+This is the extended question of the [first one](https://leetcode.com/problems/permutations/submissions/).
+The differece is there will be duplicates in the `nums`.
+
+```python
+if i>0 and options[i]==options[i-1]: continue
+```
+Above lets us skip exploring the same path.
+We can directly skip the `i` if the value is the same with `i-1`, because `dfs()` on `i-1` has already cover up all the possiblities.
+
+The time complexity is `O(N!)`.
+The space complexity is `O(N!)`, too.
+"""
+class Solution(object):
+    def permuteUnique(self, nums):
+        def dfs(path, options):
+            if len(path)==len(nums):
+                opt.append(path)
+                return
+            for i, n in enumerate(options):
+                if i>0 and options[i]==options[i-1]: continue
+                dfs(path+[n], options[:i]+options[i+1:])
+        opt = []
+        nums.sort()
+        dfs([], nums)
+        return opt

problems/permutations.py

@@ -0,0 +1,29 @@
+"""
+`nums = [1, 2, 3, 4, 5]`
+The first time you choose you can either choose 1 or 2 or 3 or 4 or 5. Lets say you choose 2. So the path so far is `[2]`.
+The second time you choose you can only choose 1 or 3 or 4 or 5. Lets say you choose 3. So the path so far is `[2, 3]`.
+The third time you choose you can only choose 1 or 4 or 5. Lets say you choose 1. So the path so far is `[2, 3, 1]`.
+The third time you choose you can only choose 4 or 5...
+.
+.
+.
+
+We put the numbers we can choose in the `options` parameter. And the path so far in the `path` parameter.
+In each `dfs()` we check if the path has used up all the numbers in the `nums`. If true. Append it in the output.
+If not, we explore all the posible path in the `options` by `dfs()`.
+
+The time complexity is O(N!). Since in this example our choices is 5 at the beginning, then 4, then 3, then 2, then 1.
+The space complexity is O(N!), too. And the recursion takes N level of recursion.
+"""
+class Solution(object):
+    def permute(self, nums):
+        def dfs(path, options):
+            if len(nums)==len(path):
+                opt.append(path)
+                return
+            for i, nums in enumerate(options):
+                dfs(path+[nums], options[:i]+options[i+1:])
+
+        opt = []
+        dfs([], nums)
+        return opt

problems/word-search.py

@@ -0,0 +1,78 @@
+"""
+Iterate through the board.
+When we spot a starting point, we `dfs()` to see if it can finish the word.
+To prevent travel to the visited node, we use a hash-set `set()` to keep track of what we have visited.
+`l` is the index of the character in the `word` we are checking.
+Note that we need to use `visited.copy()` to copy a whole new hash-set, or all the `dfs()` will use the same hash-set, which is not what we want.
+
+The time complexity is `O(N^2)`, `N` is the number of nodes. You can think of it as for each node, we have to decided to go ot not to go, and we need to make the decision `MN` times.
+The space complexity is `O(W*N)`, `W` is the length of `word`. Because the recursion level is `W`, and for each recursion we need to keep track of `visited`, which potensially takes `O(N)`.
+"""
+class Solution(object):
+    def exist(self, board, word):
+        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, visited):
+            if l==len(word)-1: return True
+            visited.add((i, j))
+            for ni, nj in getNeighbor(i, j):
+                if (ni, nj) not in visited and board[ni][nj]==word[l+1]:
+                    if dfs(ni, nj, l+1, visited.copy()): return True
+            return False
+
+        M = len(board)
+        N = len(board[0])
+
+        for i in xrange(M):
+            for j in xrange(N):
+                if board[i][j]==word[0]:
+                    if dfs(i, j, 0, set()): return True
+
+        return False
+
+"""
+As you see, the above solution takes lots of space.
+Another way is to change the character on the `board` to `#` to represent it as visited.
+After the `dfs()` call we need to change it back. Because other branch of `dfs()` might not need visit this node, or haven't visit this node.
+
+The time complexity is `O(N^2)`, `N` is the number of nodes.
+The space complexity is `O(W)`, `W` is the length of `word`. Because the recursion level is `W`.
+This answer is inspired by @caikehe's [solution](https://leetcode.com/problems/word-search/discuss/27660/).
+"""
+class Solution(object):
+    def exist(self, board, word):
+        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):
+            if l==len(word)-1 and board[i][j]==word[l]: return True
+            if board[i][j]!=word[l]: return False
+
+            char = board[i][j]
+            board[i][j] = '#'
+
+            for ni, nj in getNeighbor(i, j):
+                if dfs(ni, nj, l+1): return True
+
+            board[i][j] = char
+            return False
+
+        M = len(board)
+        N = len(board[0])
+
+        for i in xrange(M):
+            for j in xrange(N):
+                if dfs(i, j, 0): return True
+
+        return False