diff --git a/.gitignore b/.gitignore
old mode 100644
new mode 100755
diff --git a/README.md b/README.md
old mode 100644
new mode 100755
index dd42196..28486a9
--- a/README.md
+++ b/README.md
@@ -1,9 +1,9 @@
 # Overview
-1. This is my Python (2.7) Leetcode solution.
+1. This is my Python Leetcode solution.
 As time grows, this also become a guide to prepare for software engineer interview.
 
-2. The solution is at `problems/the-file-name/`.
-For example, `merge-sorted-array.py`'s solution is at `https://leetcode.com/problems/merge-sorted-array/`.
+1. The solution is at `problems/python/` or `problems/python3/`.
+For example, `merge-sorted-array.py`'s solution is at `https://leetcode.com/problems/python/merge-sorted-array/`.
 
 2. I really take time tried to make the best solution and collect the best resource that I found.  
 Because I wanted to help others like me.  
@@ -13,6 +13,7 @@ Please [BUY ME A COFFEE](https://www.buymeacoffee.com/chriswu) if you want to sh
 # Leetcode Problem Lists
 I found it makes sense to solve 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.
 
+* https://neetcode.io/practice (150 problems with video explaination)
 * https://www.programcreek.com/2013/08/leetcode-problem-classification/
 * https://github.com/wisdompeak/LeetCode
 * https://docs.google.com/spreadsheets/d/1SbpY-04Cz8EWw3A_LBUmDEXKUMO31DBjfeMoA0dlfIA/edit#gid=126913158 ([huahua](https://www.youtube.com/user/xxfflower/videos)).
@@ -37,7 +38,7 @@ I found it makes sense to solve similar problems together, so that we can recogn
 3. [What should I know from the CLRS 3rd edition book if my aim is to get into Google?](https://www.quora.com/What-should-I-know-from-the-CLRS-3rd-edition-book-if-my-aim-is-to-get-into-Google/answer/Jimmy-Saade)
 
 ## Data Structures and Algorithms for beginners
-If you are new or know nothing about data structures and algorithms, I recommend [this course](<https://classroom.udacity.com/courses/ud513>). This course is taught in Python and design to help you find job and do well in the interview.
+If you are new or know nothing about data structures and algorithms, I recommend [this course](<https://www.udacity.com/course/data-structures-and-algorithms-in-python--ud513>). This course is taught in Python and design to help you find job and do well in the interview.
 
 
 # System Design
diff --git "a/common/bellman\342\200\223ford.py" "b/common/bellman\342\200\223ford.py"
old mode 100644
new mode 100755
diff --git a/common/binary-search-tree.py b/common/binary-search-tree.py
old mode 100644
new mode 100755
diff --git a/common/bst-in-order.py b/common/bst-in-order.py
old mode 100644
new mode 100755
diff --git a/common/dijkstra.py b/common/dijkstra.py
old mode 100644
new mode 100755
diff --git a/common/heap-sort.py b/common/heap-sort.py
old mode 100644
new mode 100755
index eb2e11c..3d56e39
--- a/common/heap-sort.py
+++ b/common/heap-sort.py
@@ -1,35 +1,33 @@
+#O(LogN), used when part of the array is already heapified.
+def heapify(A, N, i):
+	largest = i
+	l = i*2+1
+	r = i*2+2
+
+	if l<N and A[l]>A[largest]: largest = l
+	if r<N and A[r]>A[largest]: largest = r
+	if largest!=i:
+		A[largest], A[i] = A[i], A[largest]
+		heapify(A, N, largest)
+
+#O(NLogN)
 def heapSort(A):
-	#build max heap
-	def heapify(A, n, i):
-		if i>=n: return
-		l, r = i*2+1, i*2+2
-		left = A[l] if l<n else float('-inf')
-		right = A[r] if r<n else float('-inf')
-
-		if left>A[i] or right>A[i]:
-			if left>right:
-				A[i], A[l] = A[l], A[i]
-				heapify(A, n, l)
-			else:
-				A[i], A[r] = A[r], A[i]
-				heapify(A, n, r)
-
-	n = len(A)
-
-	for i in reversed(xrange(n)):
-		heapify(A, n, i)
-
-	for i in reversed(xrange(1, n)):
-		A[i], A[0] = A[0], A[i]
+	N = len(A)
+
+	#build max heap, O(NLogN). Can be optimized to the O(N).
+	for i in range(N//2-1, -1, -1):
+		heapify(A, N, i)
+	
+	#keep swapping the largest
+	for i in range(N-1, -1, -1):
+		A[0], A[i] = A[i], A[0]
 		heapify(A, i, 0)
 
 
-
-A = [21, 4, 1, 3, 9, 20, 25, 6, 21, 14]
+A = [12, 11, 13, 5, 6, 7]
 heapSort(A)
-print A
+print(A)
 
-"""
-Time Complexity O(NLogN) in best, average, worst case.
-Space Complexity O(1)
-"""
\ No newline at end of file
+A = [1, 3, 5, 4, 6, 13, 10, 9, 8, 15, 17]
+heapSort(A)
+print(A)
\ No newline at end of file
diff --git a/common/insertion-sort.py b/common/insertion-sort.py
old mode 100644
new mode 100755
diff --git a/common/knapsack.py b/common/knapsack.py
old mode 100644
new mode 100755
diff --git a/common/merge-sort-in-place.py b/common/merge-sort-in-place.py
old mode 100644
new mode 100755
diff --git a/common/merge-sort.py b/common/merge-sort.py
old mode 100644
new mode 100755
diff --git a/common/min-heap.py b/common/min-heap.py
old mode 100644
new mode 100755
diff --git a/common/quick-sort.py b/common/quick-sort.py
old mode 100644
new mode 100755
diff --git a/common/radix-sort.py b/common/radix-sort.py
old mode 100644
new mode 100755
diff --git a/common/trie.py b/common/trie.py
old mode 100644
new mode 100755
diff --git a/problems/accounts-merge.py b/problems/accounts-merge.py
deleted file mode 100644
index 30e4787..0000000
--- a/problems/accounts-merge.py
+++ /dev/null
@@ -1,52 +0,0 @@
-from collections import defaultdict
-
-class Solution(object):
-    def accountsMerge(self, accounts):
-        graph = defaultdict(list)
-        merged = set()
-        ans = []
-
-        #[0]
-        for data in accounts:
-            emails = data[1:]
-            for i, email in enumerate(emails):
-                graph[email].extend(emails[:i])
-                graph[email].extend(emails[i+1:])
-        
-        for data in accounts:
-            name = data[0]
-            visited = set()
-            stack = [data[1]] #[2]
-
-            if data[1] in merged: continue #[1]
-            
-            while stack:
-                e = stack.pop()
-                if e in visited: continue
-                visited.add(e)
-                stack.extend(graph[e])
-            
-            merged.update(visited)
-            ans.append([name]+sorted(list(visited))) #[3]
-        
-        return ans
-
-"""
-Treat each email as a node.
-Build an adjacency graph. [0]
-
-For every account's data
-First, lets check if the first email is already merged. [1]
-If the first email is already merged to other groups, then other emails will be in another group as well.
-So don't need to check.
-
-Second, do a DFS starting from the first email. Put all the connected nodes into visited. [2]
-And append the sorted(visited) to the ans with name. [3]
-
-Let N be the total number of emails. M be the total number of final groups.
-Build the graph takes O(N).
-For each final groups, we make a DFS to all nodes, taking O(MN).
-Sort the group takes O((N/M)*Log(N/M)) -> O((N/M)*(logN-LogM))
-Time: O(MN)
-Space: O(N)
-"""
\ No newline at end of file
diff --git a/problems/k-closest-points-to-origin.py b/problems/k-closest-points-to-origin.py
deleted file mode 100644
index 8af9889..0000000
--- a/problems/k-closest-points-to-origin.py
+++ /dev/null
@@ -1,15 +0,0 @@
-class Solution(object):
-    def kClosest(self, points, k):
-        h = []
-        
-        for x, y in points:
-            d = (x**2+y**2)**0.5
-            if len(h)>=k and -h[0][0]>d:
-                heapq.heappop(h)
-                heapq.heappush(h, (-d, x, y))
-            elif len(h)>=k and -h[0][0]<=d:
-                pass
-            else:
-                heapq.heappush(h, (-d, x, y))
-        
-        return [(x, y) for _, x, y in h]
\ No newline at end of file
diff --git a/problems/logger-rate-limiter.py b/problems/logger-rate-limiter.py
deleted file mode 100644
index 2a1a7e6..0000000
--- a/problems/logger-rate-limiter.py
+++ /dev/null
@@ -1,10 +0,0 @@
-class Logger(object):
-    def __init__(self):
-        self.log = collections.Counter() #store the latest timestamp
-
-    def shouldPrintMessage(self, timestamp, message):
-        if message not in self.log or self.log[message]+10<=timestamp:
-            self.log[message] = timestamp
-            return True
-        else:
-            return False
\ No newline at end of file
diff --git a/problems/maximal-square.py b/problems/maximal-square.py
deleted file mode 100644
index 4ba17d6..0000000
--- a/problems/maximal-square.py
+++ /dev/null
@@ -1,13 +0,0 @@
-class Solution(object):
-    def maximalSquare(self, grid):
-        if not grid or not grid[0]: return 
-        M, N = len(grid), len(grid[0])
-        
-        dp = [[0 for _ in xrange(N+1)] for _ in xrange(M+1)]
-        ans = 0
-        for i in xrange(M):
-            for j in xrange(N):
-                if grid[i][j]=='1':
-                    dp[i+1][j+1] = min(dp[i][j], dp[i][j+1], dp[i+1][j])+1
-                    ans = max(ans, dp[i+1][j+1])
-        return ans**2
\ No newline at end of file
diff --git a/problems/next-permutation.py b/problems/next-permutation.py
deleted file mode 100644
index f228cc4..0000000
--- a/problems/next-permutation.py
+++ /dev/null
@@ -1,32 +0,0 @@
-"""
-This answer is the python version of the offical answer.
-
-Time: O(N)
-Space: O(1)
-"""
-class Solution(object):
-    def nextPermutation(self, nums):
-        def reverse(start):
-            end = len(nums)-1
-            
-            while start<end:
-                swap(start, end)
-                start += 1
-                end -= 1
-        
-        def swap(i, j):
-            nums[i], nums[j] = nums[j], nums[i]
-        
-        
-        i = len(nums)-2
-        
-        while i>=0 and nums[i+1]<=nums[i]:
-            i -= 1
-        
-        if i>=0:
-            j = len(nums)-1
-            while nums[j]<=nums[i]: j -= 1
-            swap(i, j)
-        
-        reverse(i+1)
-        return nums
\ No newline at end of file
diff --git a/problems/profitable-schemes.py b/problems/profitable-schemes.py
deleted file mode 100644
index ead8e92..0000000
--- a/problems/profitable-schemes.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""
-TLE
-dp[i][n][p] := considering profit[:i], what is the number of ways produce profit p with n people.
-"""
-class Solution(object):
-    def profitableSchemes(self, maxMember, minProfit, group, profit):
-        P = sum(profit)
-        N = sum(group)
-        dp = [[[0 for _ in xrange(P+1)] for _ in xrange(N+1)] for _ in xrange(len(profit)+1)]
-        dp[0][0][0] = 1
-        
-        count = 0
-        for i in xrange(1, len(profit)+1):
-            for n in xrange(N+1):
-                for p in xrange(P+1):
-                    dp[i][n][p] = (dp[i-1][n-group[i-1]][p-profit[i-1]] if p-profit[i-1]>=0 and n-group[i-1]>=0 else 0) + dp[i-1][n][p]
-                    if i==len(profit) and p>=minProfit and n<=maxMember: count += dp[i][n][p]
-        return count
-        
\ No newline at end of file
diff --git a/problems/01-matrix.py b/problems/python/01-matrix.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/01-matrix.py
rename to problems/python/01-matrix.py
diff --git a/problems/3sum-closest.py b/problems/python/3sum-closest.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/3sum-closest.py
rename to problems/python/3sum-closest.py
diff --git a/problems/3sum.py b/problems/python/3sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/3sum.py
rename to problems/python/3sum.py
diff --git a/problems/4sum.py b/problems/python/4sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/4sum.py
rename to problems/python/4sum.py
diff --git a/problems/python/accounts-merge.py b/problems/python/accounts-merge.py
new file mode 100755
index 0000000..91e03ef
--- /dev/null
+++ b/problems/python/accounts-merge.py
@@ -0,0 +1,134 @@
+"""
+Treat each email as a node.
+Build an adjacency graph. [0]
+
+For every account's data
+First, lets check if the first email is already merged. [1]
+If the first email is already merged to other groups, then other emails will be in another group as well.
+So don't need to check.
+
+Second, do a DFS starting from the first email. Put all the connected nodes into visited. [2]
+And append the sorted(visited) to the ans with name. [3]
+
+Let N be the total number of emails. M be the total number of final groups.
+Build the graph takes O(N).
+For each final groups, we make a DFS to all nodes, taking O(MN).
+Sort the group takes O((N/M)*Log(N/M)) -> O((N/M)*(logN-LogM))
+Time: O(MN)
+Space: O(N)
+"""
+from collections import defaultdict
+
+class Solution(object):
+    def accountsMerge(self, accounts):
+        graph = defaultdict(list)
+        merged = set()
+        ans = []
+
+        #[0]
+        for data in accounts:
+            emails = data[1:]
+            for i, email in enumerate(emails):
+                graph[email].extend(emails[:i])
+                graph[email].extend(emails[i+1:])
+        
+        for data in accounts:
+            name = data[0]
+            visited = set()
+            stack = [data[1]] #[2]
+
+            if data[1] in merged: continue #[1]
+            
+            while stack:
+                e = stack.pop()
+                if e in visited: continue
+                visited.add(e)
+                stack.extend(graph[e])
+            
+            merged.update(visited)
+            ans.append([name]+sorted(list(visited))) #[3]
+        
+        return ans
+
+
+#Union Find
+class Solution(object):
+    def accountsMerge(self, accounts):
+        def find(x):
+            p = parents[x]
+            while p!=parents[p]:
+                p = find(p)
+            parents[x] = p
+            return p
+        
+        def union(x, y):
+            p1, p2 = find(x), find(y)
+            if p1==p2: return
+            parents[p2] = p1
+        
+        parents = {}
+        mailToName = {}
+        
+        for account in accounts:
+            name = account[0]
+            root = account[1]
+            if root not in parents: parents[root] = root
+            root = find(root)
+            mailToName[root] = name
+            
+            for i in xrange(2, len(account)):
+                email = account[i]
+                if email in parents:
+                    union(parents[email], root)
+                    root = find(root)
+                parents[email] = root
+        
+        rootToMails = collections.defaultdict(list)
+        for email in parents:
+            rootToMails[find(email)].append(email)
+        
+        ans = []
+        for root in rootToMails:
+            name = mailToName[root]
+            mails = rootToMails[root]
+            ans.append([name]+sorted(mails))
+        
+        return ans
+
+#DFS
+class Solution(object):
+    def accountsMerge(self, accounts):
+        
+        #build adjacency list
+        adj = collections.defaultdict(list)
+        for account in accounts:
+            name = account[0]
+            email0 = account[1]
+            for i in xrange(2, len(account)):
+                email = account[i]
+                adj[email0].append(email)
+                adj[email].append(email0)
+        
+        #iterate accounts and dfs each email group
+        ans = []
+        visited = set() #store all the visited email
+        for account in accounts:
+            name = account[0]
+            email0 = account[1]
+            if email0 in visited: continue
+            
+            #dfs
+            group = set() #store the email group related to email0
+            stack = [email0]
+            while stack:
+                email = stack.pop()
+                if email in group or email in visited: continue
+                group.add(email)
+                visited.add(email)
+                for nei in adj[email]:
+                    stack.append(nei)
+            
+            ans.append([name]+sorted(list(group)))
+        
+        return ans
+            
\ No newline at end of file
diff --git a/problems/add-binary.py b/problems/python/add-binary.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/add-binary.py
rename to problems/python/add-binary.py
diff --git a/problems/add-digits.py b/problems/python/add-digits.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/add-digits.py
rename to problems/python/add-digits.py
diff --git a/problems/python/add-strings.py b/problems/python/add-strings.py
new file mode 100755
index 0000000..9cdd7f9
--- /dev/null
+++ b/problems/python/add-strings.py
@@ -0,0 +1,34 @@
+class Solution(object):
+    def addStrings(self, nums1, nums2):
+        ans = ''
+        i = len(nums1)-1
+        j = len(nums2)-1
+        
+        carry = 0
+        while 0<=i and 0<=j:
+            n1 = int(nums1[i])
+            n2 = int(nums2[j])
+            total = n1+n2+carry
+            n = total%10
+            carry = 1 if total>=10 else 0
+            ans = str(n)+ans
+            i -= 1
+            j -= 1
+        
+        while 0<=i:
+            total = int(nums1[i])+carry
+            n = total%10
+            carry = 1 if total>=10 else 0
+            ans = str(n)+ans
+            i -= 1
+        
+        while 0<=j:
+            total = int(nums2[j])+carry
+            n = total%10
+            carry = 1 if total>=10 else 0
+            ans = str(n)+ans
+            j -= 1
+        
+        if carry: ans = str(carry)+ans
+        
+        return ans
\ No newline at end of file
diff --git a/problems/add-two-numbers-ii.py b/problems/python/add-two-numbers-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/add-two-numbers-ii.py
rename to problems/python/add-two-numbers-ii.py
diff --git a/problems/add-two-numbers.py b/problems/python/add-two-numbers.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/add-two-numbers.py
rename to problems/python/add-two-numbers.py
diff --git a/problems/alien-dictionary.py b/problems/python/alien-dictionary.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/alien-dictionary.py
rename to problems/python/alien-dictionary.py
diff --git a/problems/all-nodes-distance-k-in-binary-tree.py b/problems/python/all-nodes-distance-k-in-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/all-nodes-distance-k-in-binary-tree.py
rename to problems/python/all-nodes-distance-k-in-binary-tree.py
diff --git a/problems/python/amount-of-new-area-painted-each-day.py b/problems/python/amount-of-new-area-painted-each-day.py
new file mode 100755
index 0000000..a5504d5
--- /dev/null
+++ b/problems/python/amount-of-new-area-painted-each-day.py
@@ -0,0 +1,40 @@
+"""
+1. Build sorted records = [(position, index, isStart)...]
+2. Iterate through all positions and maintain a box with all the "index" of the records its position is in start ~ end
+3. The smallest index in the box is the actual one that is paiting.
+
+Time: O(NLogN+P), N is the count of paint. Sorting the records takes NLogN. P is the max position.
+Although there is a while loop when iterate through P, each record is only being iterated once.
+O(NLogN + P + NLogN) ~= O(NLogN + P)
+Space: O(N)
+"""
+from sortedcontainers import SortedList
+
+class Solution(object):
+    def amountPainted(self, paint):
+        ans = [0]*len(paint)
+        box = SortedList()
+        records = []
+        maxPos = float('-inf')
+        
+        #[1]
+        for i, (start, end) in enumerate(paint):
+            records.append((start, i, -1))
+            records.append((end, i, 1))
+            maxPos = max(maxPos, end)
+        
+        records.sort()
+        
+        #[2]
+        i = 0
+        for pos in xrange(maxPos+1):
+            while i<len(records) and records[i][0]==pos:
+                _, index, t = records[i]
+                if t==-1:
+                    box.add(index)
+                else:
+                    box.remove(index)
+                i += 1
+            
+            if box: ans[box[0]] += 1 #[3]
+        return ans
\ No newline at end of file
diff --git a/problems/analyze-user-website-visit-pattern.py b/problems/python/analyze-user-website-visit-pattern.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/analyze-user-website-visit-pattern.py
rename to problems/python/analyze-user-website-visit-pattern.py
diff --git a/problems/backspace-string-compare.py b/problems/python/backspace-string-compare.py
old mode 100644
new mode 100755
similarity index 81%
rename from problems/backspace-string-compare.py
rename to problems/python/backspace-string-compare.py
index f3df6d2..cec9e8a
--- a/problems/backspace-string-compare.py
+++ b/problems/python/backspace-string-compare.py
@@ -82,4 +82,24 @@ def backspaceCompare(self, s1, s2):
             j -= 1
             
         return True
-        
\ No newline at end of file
+
+
+class Solution(object):
+    def backspaceCompare(self, s, t):
+        def helper(S):
+            ans = ''
+            i = len(S)-1
+            backspaceCount = 0
+            
+            while i>=0:
+                if S[i]=='#':
+                    backspaceCount += 1
+                else:
+                    if backspaceCount>0:
+                        backspaceCount -= 1
+                    else:
+                        ans += S[i]
+                i -= 1
+            return ans
+        
+        return helper(s)==helper(t)
\ No newline at end of file
diff --git a/problems/python/balance-a-binary-search-tree.py b/problems/python/balance-a-binary-search-tree.py
new file mode 100755
index 0000000..015934d
--- /dev/null
+++ b/problems/python/balance-a-binary-search-tree.py
@@ -0,0 +1,36 @@
+"""
+Imagine a list of sorted nodes, if we wanted to use the nodes to form a balanced BST, which root should we use?
+Yes, the one in the middle, since it can evenly spread two groups of nodes. This is what `getRoot()` does.
+And we do the same for the left half and right half. And so on. And so on...
+
+Time: O(N), N is the number of nodes.
+Space: O(N)
+"""
+class Solution(object):
+    def balanceBST(self, root):
+        def getInorderNodes(root):
+            nodes = []
+            stack = []
+            node = root
+            
+            while node or stack:
+                while node:
+                    stack.append(node)
+                    node = node.left
+                
+                node = stack.pop()
+                nodes.append(node)
+                node = node.right
+            
+            return nodes
+                
+        def getRoot(l, r):
+            if l>r: return None
+            m = (l+r)/2
+            root = inorderNodes[m]
+            root.left = getRoot(l, m-1)
+            root.right = getRoot(m+1, r)
+            return root
+            
+        inorderNodes = getInorderNodes(root)
+        return getRoot(0, len(inorderNodes)-1)
\ No newline at end of file
diff --git a/problems/balanced-binary-tree.py b/problems/python/balanced-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/balanced-binary-tree.py
rename to problems/python/balanced-binary-tree.py
diff --git a/problems/python/basic-calculator-ii.py b/problems/python/basic-calculator-ii.py
new file mode 100755
index 0000000..90ab539
--- /dev/null
+++ b/problems/python/basic-calculator-ii.py
@@ -0,0 +1,31 @@
+class Solution(object):
+    def calculate(self, s):
+        s += '+' #edge case, for last operation to be executed.
+        lastOperation = '+' #edge case, for the first currNum
+        operations = set(['+', '-', '*', '/'])
+        
+        stack = []
+        currNum = 0
+
+        for c in s:
+            if c.isdigit():
+                currNum = currNum*10 + int(c)
+            elif c in operations:
+                if lastOperation=='+':
+                    stack.append(currNum)
+                    currNum = 0
+                elif lastOperation=='-':
+                    stack.append(-currNum)
+                    currNum = 0
+                elif lastOperation=='*':
+                    currNum = stack.pop() * currNum
+                    stack.append(currNum)
+                    currNum = 0
+                elif lastOperation=='/':
+                    currNum = stack.pop() / currNum
+                    if currNum<0: currNum += 1
+                    stack.append(currNum)
+                    currNum = 0
+                lastOperation = c
+        
+        return sum(stack)
\ No newline at end of file
diff --git a/problems/best-time-to-buy-an-stock.py b/problems/python/best-time-to-buy-an-stock.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/best-time-to-buy-an-stock.py
rename to problems/python/best-time-to-buy-an-stock.py
diff --git a/problems/best-time-to-buy-and-sell-stock-iii.py b/problems/python/best-time-to-buy-and-sell-stock-iii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/best-time-to-buy-and-sell-stock-iii.py
rename to problems/python/best-time-to-buy-and-sell-stock-iii.py
diff --git a/problems/best-time-to-buy-and-sell-stock-with-cooldown.py b/problems/python/best-time-to-buy-and-sell-stock-with-cooldown.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/best-time-to-buy-and-sell-stock-with-cooldown.py
rename to problems/python/best-time-to-buy-and-sell-stock-with-cooldown.py
diff --git a/problems/best-time-to-buy-and-sell-stock.py b/problems/python/best-time-to-buy-and-sell-stock.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/best-time-to-buy-and-sell-stock.py
rename to problems/python/best-time-to-buy-and-sell-stock.py
diff --git a/problems/big-countries.sql b/problems/python/big-countries.sql
old mode 100644
new mode 100755
similarity index 100%
rename from problems/big-countries.sql
rename to problems/python/big-countries.sql
diff --git a/problems/binary-search-tree-iterator.py b/problems/python/binary-search-tree-iterator.py
old mode 100644
new mode 100755
similarity index 71%
rename from problems/binary-search-tree-iterator.py
rename to problems/python/binary-search-tree-iterator.py
index 65557ce..48d1458
--- a/problems/binary-search-tree-iterator.py
+++ b/problems/python/binary-search-tree-iterator.py
@@ -61,4 +61,28 @@ def inOrderTraverse(root):
         #do something
         print node.val
         
-        node = node.right
\ No newline at end of file
+        node = node.right
+
+
+
+class BSTIterator(object):
+
+    def __init__(self, root):
+        self.stack = []
+        self.node = root
+        
+        
+
+    def next(self):
+        while self.node:
+            self.stack.append(self.node)
+            self.node = self.node.left
+        self.node = self.stack.pop()
+        returnVal = self.node.val
+        self.node = self.node.right
+        return returnVal
+        
+        
+
+    def hasNext(self):
+        return self.node or self.stack
\ No newline at end of file
diff --git a/problems/binary-search.py b/problems/python/binary-search.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-search.py
rename to problems/python/binary-search.py
diff --git a/problems/binary-subarrays-with-sum.py b/problems/python/binary-subarrays-with-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-subarrays-with-sum.py
rename to problems/python/binary-subarrays-with-sum.py
diff --git a/problems/binary-tree-inorder-traversal.py b/problems/python/binary-tree-inorder-traversal.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-tree-inorder-traversal.py
rename to problems/python/binary-tree-inorder-traversal.py
diff --git a/problems/binary-tree-level-order-traversal-ii.py b/problems/python/binary-tree-level-order-traversal-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-tree-level-order-traversal-ii.py
rename to problems/python/binary-tree-level-order-traversal-ii.py
diff --git a/problems/binary-tree-level-order-traversal.py b/problems/python/binary-tree-level-order-traversal.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-tree-level-order-traversal.py
rename to problems/python/binary-tree-level-order-traversal.py
diff --git a/problems/binary-tree-longest-consecutive-sequence.py b/problems/python/binary-tree-longest-consecutive-sequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-tree-longest-consecutive-sequence.py
rename to problems/python/binary-tree-longest-consecutive-sequence.py
diff --git a/problems/binary-tree-maximum-path-sum.py b/problems/python/binary-tree-maximum-path-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-tree-maximum-path-sum.py
rename to problems/python/binary-tree-maximum-path-sum.py
diff --git a/problems/binary-tree-paths.py b/problems/python/binary-tree-paths.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-tree-paths.py
rename to problems/python/binary-tree-paths.py
diff --git a/problems/binary-tree-pruning.py b/problems/python/binary-tree-pruning.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-tree-pruning.py
rename to problems/python/binary-tree-pruning.py
diff --git a/problems/binary-tree-right-side-view.py b/problems/python/binary-tree-right-side-view.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-tree-right-side-view.py
rename to problems/python/binary-tree-right-side-view.py
diff --git a/problems/binary-tree-vertical-order-traversal.py b/problems/python/binary-tree-vertical-order-traversal.py
old mode 100644
new mode 100755
similarity index 51%
rename from problems/binary-tree-vertical-order-traversal.py
rename to problems/python/binary-tree-vertical-order-traversal.py
index ac0f3c6..1510ac0
--- a/problems/binary-tree-vertical-order-traversal.py
+++ b/problems/python/binary-tree-vertical-order-traversal.py
@@ -24,4 +24,27 @@ def verticalOrder(self, root):
             if node.left: q.append((node.left, x-1))
             if node.right: q.append((node.right, x+1))
             
-        return [ans[x] for x in xrange(minX, maxX+1)]
\ No newline at end of file
+        return [ans[x] for x in xrange(minX, maxX+1)]
+
+
+class Solution(object):
+    def verticalOrder(self, root):
+        if not root: return []
+        ans = []
+        minX = float('inf')
+        maxX = float('-inf')
+        locations = collections.defaultdict(list)
+        q = collections.deque([(root, 0)])
+        
+        while q:
+            node, x = q.popleft()
+            locations[x].append(node.val)
+            minX = min(minX, x)
+            maxX = max(maxX, x)
+            if node.left: q.append((node.left, x-1))
+            if node.right: q.append((node.right, x+1))
+        
+        for x in xrange(minX, maxX+1):
+            if locations[x]: ans.append(locations[x])
+                
+        return ans
\ No newline at end of file
diff --git a/problems/binary-watch.py b/problems/python/binary-watch.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/binary-watch.py
rename to problems/python/binary-watch.py
diff --git a/problems/python/buildings-with-an-ocean-view.py b/problems/python/buildings-with-an-ocean-view.py
new file mode 100755
index 0000000..0025b13
--- /dev/null
+++ b/problems/python/buildings-with-an-ocean-view.py
@@ -0,0 +1,16 @@
+"""
+Traverse from the right and keep track of the highest building.
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def findBuildings(self, heights):
+        ans = []
+        currMaxHeight = 0
+        for i in xrange(len(heights)-1, -1, -1):
+            h = heights[i]
+            if h>currMaxHeight: ans.append(i)
+            currMaxHeight = max(currMaxHeight, h)
+        
+        return reversed(ans)
\ No newline at end of file
diff --git a/problems/burst-balloons.py b/problems/python/burst-balloons.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/burst-balloons.py
rename to problems/python/burst-balloons.py
diff --git a/problems/python/campus-bikes-ii.py b/problems/python/campus-bikes-ii.py
new file mode 100755
index 0000000..a292d91
--- /dev/null
+++ b/problems/python/campus-bikes-ii.py
@@ -0,0 +1,35 @@
+"""
+state[i] := ith bike has been selected.
+For example, there are M bikes, 0000, 0100, 0110, 1111.....
+
+Time: O(ELogE)
+Space: O(E)
+"""
+class Solution(object):
+    def assignBikes(self, workers, bikes):
+        M = len(bikes)
+        N = len(workers)
+        costs = [[0]*N for _ in xrange(M)]
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                costs[i][j] = abs(workers[j][0]-bikes[i][0])+abs(workers[j][1]-bikes[i][1])
+        
+        pq = [(0, '0'*M)]
+        visited = set()
+        while pq:
+            cost, state = heapq.heappop(pq)
+            if state in visited: continue
+            visited.add(state)
+            
+            j = state.count('1') #j users have selected bikes
+            if j>=N: return cost
+            
+            for i in xrange(M):
+                if state[i]=='1': continue
+                
+                nextState = state[:i] + '1' + state[i+1:]
+                if nextState in visited: continue
+                heapq.heappush(pq, (cost+costs[i][j], nextState))
+        
+        return float('inf')
\ No newline at end of file
diff --git a/problems/candy.py b/problems/python/candy.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/candy.py
rename to problems/python/candy.py
diff --git a/problems/capacity-to-ship-packages-within-d-days.py b/problems/python/capacity-to-ship-packages-within-d-days.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/capacity-to-ship-packages-within-d-days.py
rename to problems/python/capacity-to-ship-packages-within-d-days.py
diff --git a/problems/cheapest-flights-within-k-stops.py b/problems/python/cheapest-flights-within-k-stops.py
old mode 100644
new mode 100755
similarity index 97%
rename from problems/cheapest-flights-within-k-stops.py
rename to problems/python/cheapest-flights-within-k-stops.py
index 28b2927..eb785b3
--- a/problems/cheapest-flights-within-k-stops.py
+++ b/problems/python/cheapest-flights-within-k-stops.py
@@ -23,16 +23,19 @@ class Solution1(object):
 	def findCheapestPrice(self, n, flights, src, dst, K):
 		graph = collections.defaultdict(list)
 		pq = []
+		visited = set()
 
 		for u, v, w in flights: graph[u].append((w, v))
 
 		heapq.heappush(pq, (0, K+1, src))
 		while pq:
 			price, stops, city = heapq.heappop(pq)
+			visited.add(city)
 
 			if city is dst: return price
 			if stops>0:
 				for price_to_nei, nei in graph[city]:
+					if nei in visited: continue
 					heapq.heappush(pq, (price+price_to_nei, stops-1, nei))
 		return -1
 
diff --git a/problems/climbing-stairs.py b/problems/python/climbing-stairs.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/climbing-stairs.py
rename to problems/python/climbing-stairs.py
diff --git a/problems/clone-graph.py b/problems/python/clone-graph.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/clone-graph.py
rename to problems/python/clone-graph.py
diff --git a/problems/closest-binary-search-tree-value.py b/problems/python/closest-binary-search-tree-value.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/closest-binary-search-tree-value.py
rename to problems/python/closest-binary-search-tree-value.py
diff --git a/problems/coin-change.py b/problems/python/coin-change.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/coin-change.py
rename to problems/python/coin-change.py
diff --git a/problems/coloring-a-border.py b/problems/python/coloring-a-border.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/coloring-a-border.py
rename to problems/python/coloring-a-border.py
diff --git a/problems/combination-sum-ii.py b/problems/python/combination-sum-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/combination-sum-ii.py
rename to problems/python/combination-sum-ii.py
diff --git a/problems/combination-sum-iii.py b/problems/python/combination-sum-iii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/combination-sum-iii.py
rename to problems/python/combination-sum-iii.py
diff --git a/problems/combination-sum-iv.py b/problems/python/combination-sum-iv.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/combination-sum-iv.py
rename to problems/python/combination-sum-iv.py
diff --git a/problems/combination-sum.py b/problems/python/combination-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/combination-sum.py
rename to problems/python/combination-sum.py
diff --git a/problems/combinations.py b/problems/python/combinations.py
old mode 100644
new mode 100755
similarity index 87%
rename from problems/combinations.py
rename to problems/python/combinations.py
index 49f7ebf..f3a0937
--- a/problems/combinations.py
+++ b/problems/python/combinations.py
@@ -83,6 +83,21 @@ def dfs(n_min, path):
 
 
 
+class Solution(object):
+    def combine(self, N, K):
+        def dfs(comb, start, N, K):
+            if len(comb)==K: ans.append(comb[:])
+            
+            for n in xrange(start, N+1):
+                comb.append(n)
+                dfs(comb, n+1, N, K)
+                comb.pop()
+        
+        ans = []
+        dfs([], 1, N, K)
+        return ans
+
+
 
 
 
diff --git a/problems/combine-two-tables.sql b/problems/python/combine-two-tables.sql
old mode 100644
new mode 100755
similarity index 100%
rename from problems/combine-two-tables.sql
rename to problems/python/combine-two-tables.sql
diff --git a/problems/compare-version-numbers.py b/problems/python/compare-version-numbers.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/compare-version-numbers.py
rename to problems/python/compare-version-numbers.py
diff --git a/problems/connecting-cities-with-minimum-cost.py b/problems/python/connecting-cities-with-minimum-cost.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/connecting-cities-with-minimum-cost.py
rename to problems/python/connecting-cities-with-minimum-cost.py
diff --git a/problems/consecutive-numbers-sum.py b/problems/python/consecutive-numbers-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/consecutive-numbers-sum.py
rename to problems/python/consecutive-numbers-sum.py
diff --git a/problems/construct-binary-tree-from-inorder-and-postorder-traversal.py b/problems/python/construct-binary-tree-from-inorder-and-postorder-traversal.py
old mode 100644
new mode 100755
similarity index 67%
rename from problems/construct-binary-tree-from-inorder-and-postorder-traversal.py
rename to problems/python/construct-binary-tree-from-inorder-and-postorder-traversal.py
index 1a46912..f8304fc
--- a/problems/construct-binary-tree-from-inorder-and-postorder-traversal.py
+++ b/problems/python/construct-binary-tree-from-inorder-and-postorder-traversal.py
@@ -68,4 +68,35 @@ def helper(i, j, k, l):
         
         index = {} #the index of inorder
         for i, n in enumerate(inorder): index[n] = i
-        return helper(0, len(inorder), 0, len(postorder))
\ No newline at end of file
+        return helper(0, len(inorder), 0, len(postorder))
+
+
+
+
+
+"""
+Inorder: [LEFT]root[RIGHT]
+Postorder: [LEFT][RIGHT]root
+As you can see, rootVal is the last val in postorder.
+
+i and j is the range of the inorder
+k and l is the range of the postorder
+Get the root
+Also recursively use the same method to get the left and right node, but this time we change the inorder and postorder.
+"""
+class Solution(object):
+    def buildTree(self, inorder, postorder):
+        def helper(i, j, k, l):
+            if i>j or k>l: return None
+            rootVal = postorder[l]
+            root = TreeNode(rootVal)
+            r = inorderIndex[rootVal]
+            leftLength = r-i
+            rightLength = j-r
+            root.left = helper(i, r-1, k, k+leftLength-1)
+            root.right = helper(r+1, j, k+leftLength, k+leftLength+rightLength-1)
+            return root
+            
+        inorderIndex = {}
+        for i, n in enumerate(inorder): inorderIndex[n] = i
+        return helper(0, len(inorder)-1, 0, len(postorder)-1)
diff --git a/problems/construct-binary-tree-from-preorder-and-inorder-traversal.py b/problems/python/construct-binary-tree-from-preorder-and-inorder-traversal.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/construct-binary-tree-from-preorder-and-inorder-traversal.py
rename to problems/python/construct-binary-tree-from-preorder-and-inorder-traversal.py
diff --git a/problems/container-with-most-water.py b/problems/python/container-with-most-water.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/container-with-most-water.py
rename to problems/python/container-with-most-water.py
diff --git a/problems/contains-duplicate-ii.py b/problems/python/contains-duplicate-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/contains-duplicate-ii.py
rename to problems/python/contains-duplicate-ii.py
diff --git a/problems/contains-duplicate-iii.py b/problems/python/contains-duplicate-iii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/contains-duplicate-iii.py
rename to problems/python/contains-duplicate-iii.py
diff --git a/problems/contains-duplicate.py b/problems/python/contains-duplicate.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/contains-duplicate.py
rename to problems/python/contains-duplicate.py
diff --git a/problems/python/continuous-subarray-sum.py b/problems/python/continuous-subarray-sum.py
new file mode 100755
index 0000000..75dd08b
--- /dev/null
+++ b/problems/python/continuous-subarray-sum.py
@@ -0,0 +1,35 @@
+class Solution(object):
+    def checkSubarraySum(self, nums, k):
+        prefixSumEndings = collections.defaultdict(list)
+        prefixSumEndings[0].append(-1)
+        
+        prefixSum = 0
+        for i, n in enumerate(nums):
+            prefixSum += n
+            
+            x = prefixSum/k
+            while x>=0:
+                p2 = prefixSum-k*x
+                if len(prefixSumEndings[p2])>0 and prefixSumEndings[p2][0]<i-1:
+                    return True
+                x -= 1
+            prefixSumEndings[prefixSum].append(i)
+        
+        return False
+
+class Solution(object):
+    def checkSubarraySum(self, nums, k):
+        if len(nums)==0 or len(nums)==1: return False
+        prefixSumKRemain = collections.defaultdict(list)
+        
+        prefixSum = 0
+        for i, n in enumerate(nums):
+            prefixSum += n
+            remain = prefixSum%k
+            
+            if prefixSum%k==0 and i>=1: return True
+            if len(prefixSumKRemain[remain])>0 and prefixSumKRemain[remain][0]<i-1:
+                return True
+            prefixSumKRemain[remain].append(i)
+            
+        return False
\ No newline at end of file
diff --git a/problems/convert-binary-search-tree-to-sorted-doubly-linked-list.py b/problems/python/convert-binary-search-tree-to-sorted-doubly-linked-list.py
old mode 100644
new mode 100755
similarity index 81%
rename from problems/convert-binary-search-tree-to-sorted-doubly-linked-list.py
rename to problems/python/convert-binary-search-tree-to-sorted-doubly-linked-list.py
index cfd441f..f813a37
--- a/problems/convert-binary-search-tree-to-sorted-doubly-linked-list.py
+++ b/problems/python/convert-binary-search-tree-to-sorted-doubly-linked-list.py
@@ -101,4 +101,30 @@ def inOrderTraverse(root):
         #do something
         print node.val
         
-        node = node.right
\ No newline at end of file
+        node = node.right
+
+"""
+Time: O(N)
+Space: O(LogN)
+"""
+class Solution(object):
+    def treeToDoublyList(self, root):
+        def helper(node):
+            ll = rr = node
+            if node.left:
+                ll, lr = helper(node.left)
+                node.left = lr
+                lr.right = node
+            
+            if node.right:
+                rl, rr = helper(node.right)
+                node.right = rl
+                rl.left = node
+            
+            return ll, rr
+        
+        if not root: return root
+        left, right = helper(root)
+        right.right = left
+        left.left = right
+        return left
\ No newline at end of file
diff --git a/problems/convert-sorted-array-to-binary-search-tree.py b/problems/python/convert-sorted-array-to-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/convert-sorted-array-to-binary-search-tree.py
rename to problems/python/convert-sorted-array-to-binary-search-tree.py
diff --git a/problems/convert-sorted-list-to-binary-search-tree.py b/problems/python/convert-sorted-list-to-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/convert-sorted-list-to-binary-search-tree.py
rename to problems/python/convert-sorted-list-to-binary-search-tree.py
diff --git a/problems/copy-list-with-random-pointer.py b/problems/python/copy-list-with-random-pointer.py
old mode 100644
new mode 100755
similarity index 67%
rename from problems/copy-list-with-random-pointer.py
rename to problems/python/copy-list-with-random-pointer.py
index 0790e26..ddf901e
--- a/problems/copy-list-with-random-pointer.py
+++ b/problems/python/copy-list-with-random-pointer.py
@@ -55,5 +55,38 @@ def copyRandomList(self, head):
 
 """
 Time: O(N). Two iteration. First iteration make a the clones. Second iteration setup the links.
-Space: O(1). No extra space except the cloned node.
-"""
\ No newline at end of file
+Space: O(N).
+"""
+
+
+"""
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def copyRandomList(self, head):
+        if not head: return head
+        curr = head
+        while curr:
+            nextCurr = curr.next
+            copy = Node(curr.val)
+            curr.next = copy
+            copy.next = nextCurr
+            curr = nextCurr
+        
+        copyHead = head.next
+
+        curr = head
+        while curr:
+            if curr.random: curr.next.random = curr.random.next
+            curr = curr.next.next
+        
+        curr = head
+        while curr:
+            nextCurr = curr.next.next
+            if nextCurr:
+                curr.next.next = nextCurr.next
+            curr.next = nextCurr
+            curr = nextCurr
+        
+        return copyHead
\ No newline at end of file
diff --git a/problems/python/count-all-valid-pickup-and-delivery-opti.py b/problems/python/count-all-valid-pickup-and-delivery-opti.py
new file mode 100755
index 0000000..8bfe82a
--- /dev/null
+++ b/problems/python/count-all-valid-pickup-and-delivery-opti.py
@@ -0,0 +1,5 @@
+class Solution(object):
+    def countOrders(self, n):
+        d = 1
+        for i in xrange(1, 2*n, 2): d*=i
+        return math.factorial(n)*d % (10**9 + 7)
\ No newline at end of file
diff --git a/problems/count-binary-substrings.py b/problems/python/count-binary-substrings.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/count-binary-substrings.py
rename to problems/python/count-binary-substrings.py
diff --git a/problems/count-complete-tree-nodes.py b/problems/python/count-complete-tree-nodes.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/count-complete-tree-nodes.py
rename to problems/python/count-complete-tree-nodes.py
diff --git a/problems/count-number-of-nice-subarrays.py b/problems/python/count-number-of-nice-subarrays.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/count-number-of-nice-subarrays.py
rename to problems/python/count-number-of-nice-subarrays.py
diff --git a/problems/count-unique-characters-of-all-substrings-of-a-given-string.py b/problems/python/count-unique-characters-of-all-substrings-of-a-given-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/count-unique-characters-of-all-substrings-of-a-given-string.py
rename to problems/python/count-unique-characters-of-all-substrings-of-a-given-string.py
diff --git a/problems/course-schedule-ii.py b/problems/python/course-schedule-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/course-schedule-ii.py
rename to problems/python/course-schedule-ii.py
diff --git a/problems/course-schedule.py b/problems/python/course-schedule.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/course-schedule.py
rename to problems/python/course-schedule.py
diff --git a/problems/python/custom-sort-string.py b/problems/python/custom-sort-string.py
new file mode 100755
index 0000000..2e63523
--- /dev/null
+++ b/problems/python/custom-sort-string.py
@@ -0,0 +1,20 @@
+"""
+Take a look at the char in s.
+For the char that is in the order, rearrange them to sortedChars with respect to the "order".
+For the char that is in not the order, put them in postString.
+"""
+class Solution(object):
+    def customSortString(self, order, s):
+        sortedChars = ''
+        counter = collections.Counter(s)
+        for c in order:
+            if c in order:
+                sortedChars += c*counter[c]
+        
+        orderSet = set(order)
+        postString = ''
+        for c in s:
+            if c not in orderSet:
+                postString += c
+        
+        return sortedChars+postString
\ No newline at end of file
diff --git a/problems/python/cutting-ribbons.py b/problems/python/cutting-ribbons.py
new file mode 100755
index 0000000..175e336
--- /dev/null
+++ b/problems/python/cutting-ribbons.py
@@ -0,0 +1,13 @@
+class Solution(object):
+    def maxLength(self, ribbons, k):
+        maxLen = max(ribbons)
+        minLen = 0
+        
+        while minLen<maxLen:
+            l = minLen + (maxLen-minLen+1)/2
+            
+            if sum([ribbonLen/l for ribbonLen in ribbons])>=k:
+                minLen = l
+            else:
+                maxLen = l-1
+        return maxLen
\ No newline at end of file
diff --git a/problems/data-stream-as-disjoint-intervals.py b/problems/python/data-stream-as-disjoint-intervals.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/data-stream-as-disjoint-intervals.py
rename to problems/python/data-stream-as-disjoint-intervals.py
diff --git a/problems/decode-string.py b/problems/python/decode-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/decode-string.py
rename to problems/python/decode-string.py
diff --git a/problems/decode-ways.py b/problems/python/decode-ways.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/decode-ways.py
rename to problems/python/decode-ways.py
diff --git a/problems/delete-and-earn.py b/problems/python/delete-and-earn.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/delete-and-earn.py
rename to problems/python/delete-and-earn.py
diff --git a/problems/delete-duplicate-folders-in-system.py b/problems/python/delete-duplicate-folders-in-system.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/delete-duplicate-folders-in-system.py
rename to problems/python/delete-duplicate-folders-in-system.py
diff --git a/problems/delete-node-in-a-bst.py b/problems/python/delete-node-in-a-bst.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/delete-node-in-a-bst.py
rename to problems/python/delete-node-in-a-bst.py
diff --git a/problems/delete-operation-for-two-strings.py b/problems/python/delete-operation-for-two-strings.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/delete-operation-for-two-strings.py
rename to problems/python/delete-operation-for-two-strings.py
diff --git a/problems/design-add-and-search-words-data-structure.py b/problems/python/design-add-and-search-words-data-structure.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/design-add-and-search-words-data-structure.py
rename to problems/python/design-add-and-search-words-data-structure.py
diff --git a/problems/design-in-memory-file-system.py b/problems/python/design-in-memory-file-system.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/design-in-memory-file-system.py
rename to problems/python/design-in-memory-file-system.py
diff --git a/problems/design-linked-list.py b/problems/python/design-linked-list.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/design-linked-list.py
rename to problems/python/design-linked-list.py
diff --git a/problems/design-tic-tac-toe.py b/problems/python/design-tic-tac-toe.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/design-tic-tac-toe.py
rename to problems/python/design-tic-tac-toe.py
diff --git a/problems/python/diagonal-traverse.py b/problems/python/diagonal-traverse.py
new file mode 100755
index 0000000..0510201
--- /dev/null
+++ b/problems/python/diagonal-traverse.py
@@ -0,0 +1,25 @@
+class Solution(object):
+    def findDiagonalOrder(self, mat):
+        def helper(i, j, reverse):
+            output = []
+            while 0<=i<len(mat) and 0<=j<len(mat[0]):
+                output.append(mat[i][j])
+                i += 1
+                j -= 1
+            return output if not reverse else reversed(output)
+        
+        
+        M = len(mat)
+        N = len(mat[0])
+        ans = []
+        reverse = True
+        
+        for j in xrange(N):
+            ans += helper(0, j, reverse)
+            reverse = not reverse
+        
+        for i in xrange(1, M):
+            ans += helper(i, N-1, reverse)
+            reverse = not reverse
+        
+        return ans
\ No newline at end of file
diff --git a/problems/diameter-of-binary-tree.py b/problems/python/diameter-of-binary-tree.py
old mode 100644
new mode 100755
similarity index 81%
rename from problems/diameter-of-binary-tree.py
rename to problems/python/diameter-of-binary-tree.py
index f30ea33..8af4f9b
--- a/problems/diameter-of-binary-tree.py
+++ b/problems/python/diameter-of-binary-tree.py
@@ -83,3 +83,23 @@ def getMaxDepth(node):
             
 #         return ans
 
+
+"""
+For each route in the binary tree, we can view it from the highest node in the route.
+So the length will be helper(node.left) + 1 + helper(node.right).
+"""
+class Solution(object):
+    def __init__(self):
+        self.ans = 0 #number of nodes in the longest route
+        
+    def diameterOfBinaryTree(self, root):
+	    #return the longest length to the leaf including itself
+        #also update self.ans
+        def helper(node):
+            r = helper(node.right) if node.right else 0
+            l = helper(node.left) if node.left else 0
+            self.ans = max(self.ans, l+1+r)
+            return max(l+1, r+1)
+        
+        helper(root)
+        return self.ans-1
\ No newline at end of file
diff --git a/problems/different-ways-to-add-parentheses.py b/problems/python/different-ways-to-add-parentheses.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/different-ways-to-add-parentheses.py
rename to problems/python/different-ways-to-add-parentheses.py
diff --git a/problems/distinct-subsequences.py b/problems/python/distinct-subsequences.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/distinct-subsequences.py
rename to problems/python/distinct-subsequences.py
diff --git a/problems/distribute-coins-in-binary-tree.py b/problems/python/distribute-coins-in-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/distribute-coins-in-binary-tree.py
rename to problems/python/distribute-coins-in-binary-tree.py
diff --git a/problems/domino-and-tromino-tiling.py b/problems/python/domino-and-tromino-tiling.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/domino-and-tromino-tiling.py
rename to problems/python/domino-and-tromino-tiling.py
diff --git a/problems/python/dot-product-of-two-sparse-vectors.py b/problems/python/dot-product-of-two-sparse-vectors.py
new file mode 100755
index 0000000..be69714
--- /dev/null
+++ b/problems/python/dot-product-of-two-sparse-vectors.py
@@ -0,0 +1,16 @@
+class SparseVector:
+    def __init__(self, nums):
+        self.indices = set()
+        self.values = {}
+        
+        for i, n in enumerate(nums):
+            if n!=0:
+                self.indices.add(i)
+                self.values[i] = n
+                
+    def dotProduct(self, vec):
+        products = 0
+        indices = self.indices.intersection(vec.indices)
+        for i in indices:
+            products += self.values[i]*vec.values[i]
+        return products
\ No newline at end of file
diff --git a/problems/dungeon-game.py b/problems/python/dungeon-game.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/dungeon-game.py
rename to problems/python/dungeon-game.py
diff --git a/problems/edit-distance.py b/problems/python/edit-distance.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/edit-distance.py
rename to problems/python/edit-distance.py
diff --git a/problems/egions-cut-by-slashes.py b/problems/python/egions-cut-by-slashes.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/egions-cut-by-slashes.py
rename to problems/python/egions-cut-by-slashes.py
diff --git a/problems/evaluate-division.py b/problems/python/evaluate-division.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/evaluate-division.py
rename to problems/python/evaluate-division.py
diff --git a/problems/evaluate-reverse-polish-notation.py b/problems/python/evaluate-reverse-polish-notation.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/evaluate-reverse-polish-notation.py
rename to problems/python/evaluate-reverse-polish-notation.py
diff --git a/problems/python/exclusive-time-of-functions.py b/problems/python/exclusive-time-of-functions.py
new file mode 100755
index 0000000..0f4fc4d
--- /dev/null
+++ b/problems/python/exclusive-time-of-functions.py
@@ -0,0 +1,24 @@
+class Solution(object):
+    def exclusiveTime(self, n, logs):
+        ans = [0]*n
+        data = []
+        for log in logs:
+            fid, action, t = log.split(':')
+            data.append([int(t), -1 if action=='start' else 1, int(fid)])
+        
+        data.sort()
+        
+        stack = []
+        for t, action, fid in data:
+            if action==-1:
+                if stack:
+                    prevT, _, prevFid = stack[-1]
+                    ans[prevFid] += t-prevT
+            elif action==1:
+                prevT, _, prevFid = stack.pop()
+                ans[fid] += t+1-prevT
+                if stack: stack[-1][0] = t+1
+                
+            if action==-1: stack.append([t, action, fid])
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python/expression-add-operators.py b/problems/python/expression-add-operators.py
new file mode 100755
index 0000000..64421a7
--- /dev/null
+++ b/problems/python/expression-add-operators.py
@@ -0,0 +1,23 @@
+class Solution(object):
+    def addOperators(self, num, target):
+        def dfs(num, curr, i):
+            if i==len(num):
+                if eval(curr[1:])==target: ans.append(curr[1:])
+                return
+            
+            if curr and curr[-1] in operators:
+                dfs(num, curr+num[i], i+1)
+            elif curr and curr[-1]=='0':
+                dfs(num, curr+'+', i)
+                dfs(num, curr+'-', i)
+                dfs(num, curr+'*', i)
+            else:
+                dfs(num, curr+'+', i)
+                dfs(num, curr+'-', i)
+                dfs(num, curr+'*', i)
+                dfs(num, curr+num[i], i+1)
+        
+        operators = set(['+', '-', '*'])
+        ans = []
+        dfs(num, '+', 0)
+        return ans
\ No newline at end of file
diff --git a/problems/filling-bookcase-shelves.py b/problems/python/filling-bookcase-shelves.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/filling-bookcase-shelves.py
rename to problems/python/filling-bookcase-shelves.py
diff --git a/problems/python/find-all-possible-recipes-from-given-supplies.py b/problems/python/find-all-possible-recipes-from-given-supplies.py
new file mode 100755
index 0000000..13772ac
--- /dev/null
+++ b/problems/python/find-all-possible-recipes-from-given-supplies.py
@@ -0,0 +1,33 @@
+"""
+Use Topological Sort
+1. Build an adj list and inbound.
+2. Starts from supplies topologically traverse the map.
+3. For each node popping up, if it is in recipes, add it to ans.
+
+Time: O(N), N is the number of "nodes" (ingredients+recipes)
+Space: O(N).
+"""
+class Solution(object):
+    def findAllRecipes(self, recipes, ingredients, supplies):
+        N = len(recipes)
+        adj = collections.defaultdict(list)
+        inbounds = collections.Counter()
+        q = collections.deque(supplies)
+        recipeSet = set(recipes)
+        ans = []
+        
+        for i, recipe in enumerate(recipes):
+            for ingredient in ingredients[i]:
+                adj[ingredient].append(recipe)
+                inbounds[recipe] += 1
+        
+        while q:
+            node = q.popleft()
+            
+            if node in recipeSet: ans.append(node)
+            
+            for nei in adj[node]:
+                inbounds[nei] -= 1
+                if inbounds[nei]==0: q.append(nei)
+        
+        return ans
\ No newline at end of file
diff --git a/problems/find-and-replace-in-string.py b/problems/python/find-and-replace-in-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-and-replace-in-string.py
rename to problems/python/find-and-replace-in-string.py
diff --git a/problems/python/find-distance-in-a-binary-tree.py b/problems/python/find-distance-in-a-binary-tree.py
new file mode 100755
index 0000000..b87dd1b
--- /dev/null
+++ b/problems/python/find-distance-in-a-binary-tree.py
@@ -0,0 +1,28 @@
+class Solution(object):
+    def __init__(self):
+        self.lca = None
+        self.pHeight = 0
+        self.qHeight = 0
+        
+    def findDistance(self, root, p, q):
+        #find the count of p or q in node's subtree, set the first node we found that has count>=2 as lca.
+        def findCount(node):
+            if not node: return 0
+            count = 0
+            if node.val==p or node.val==q: count += 1
+            count += findPQCount(node.left)
+            count += findPQCount(node.right)
+            if count>=2 and not self.lca: self.lca = node
+            return count
+        
+        def findHeight(node, h):
+            if not node: return
+            if node.val==p: self.pHeight = h
+            if node.val==q: self.qHeight = h
+            if self.pHeight and self.qHeight: return
+            findHeight(node.left, h+1)
+            findHeight(node.right, h+1)
+            
+        findCount(root)
+        findHeight(self.lca, 0)
+        return self.qHeight + self.pHeight
\ No newline at end of file
diff --git a/problems/python/find-duplicate-subtrees.py b/problems/python/find-duplicate-subtrees.py
new file mode 100755
index 0000000..5729e8e
--- /dev/null
+++ b/problems/python/find-duplicate-subtrees.py
@@ -0,0 +1,16 @@
+class Solution(object):
+    def findDuplicateSubtrees(self, root):
+        def dfs(node):
+            if not node: return '#'
+            string = str(node.val) + ',' + dfs(node.left) + ',' + dfs(node.right)
+            data[string].append(node)
+            return string
+        
+        data = collections.defaultdict(list)
+        ans = []
+        
+        dfs(root)
+        
+        for s in data:
+            if len(data[s])>=2: ans.append(data[s][0])
+        return ans
\ No newline at end of file
diff --git a/problems/find-eventual-safe-states.py b/problems/python/find-eventual-safe-states.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-eventual-safe-states.py
rename to problems/python/find-eventual-safe-states.py
diff --git a/problems/find-first-and-last-position-of-element-in-sorted-array.py b/problems/python/find-first-and-last-position-of-element-in-sorted-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-first-and-last-position-of-element-in-sorted-array.py
rename to problems/python/find-first-and-last-position-of-element-in-sorted-array.py
diff --git a/problems/python/find-k-closest-elements.py b/problems/python/find-k-closest-elements.py
new file mode 100755
index 0000000..802279f
--- /dev/null
+++ b/problems/python/find-k-closest-elements.py
@@ -0,0 +1,20 @@
+class Solution(object):
+    def findClosestElements(self, arr, K, X):
+        def isCloserThan(n1, n2, x):
+            return abs(x-n1)<abs(x-n2) or (abs(x-n1)==abs(x-n2) and n1<n2)
+                
+        output1 = []
+        output2 = []
+        
+        r = bisect.bisect_left(arr, X)
+        l = r-1
+        
+        while len(output1)+len(output2)<K:
+            if r>=len(arr) or (l>=0 and isCloserThan(arr[l], arr[r], X)):
+                output1.append(arr[l])
+                l -= 1
+            else:
+                output2.append(arr[r])
+                r += 1
+        
+        return output1[::-1]+output2
diff --git a/problems/find-k-pairs-with-smallest-sums.py b/problems/python/find-k-pairs-with-smallest-sums.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-k-pairs-with-smallest-sums.py
rename to problems/python/find-k-pairs-with-smallest-sums.py
diff --git a/problems/find-leaves-of-binary-tree.py b/problems/python/find-leaves-of-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-leaves-of-binary-tree.py
rename to problems/python/find-leaves-of-binary-tree.py
diff --git a/problems/find-median-from-data-stream.py b/problems/python/find-median-from-data-stream.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-median-from-data-stream.py
rename to problems/python/find-median-from-data-stream.py
diff --git a/problems/find-minimum-in-rotated-sorted-array-ii.py b/problems/python/find-minimum-in-rotated-sorted-array-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-minimum-in-rotated-sorted-array-ii.py
rename to problems/python/find-minimum-in-rotated-sorted-array-ii.py
diff --git a/problems/find-minimum-in-rotated-sorted-array.py b/problems/python/find-minimum-in-rotated-sorted-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-minimum-in-rotated-sorted-array.py
rename to problems/python/find-minimum-in-rotated-sorted-array.py
diff --git a/problems/find-mode-in-binary-search-tree.py b/problems/python/find-mode-in-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-mode-in-binary-search-tree.py
rename to problems/python/find-mode-in-binary-search-tree.py
diff --git a/problems/find-original-array-from-doubled-array,py b/problems/python/find-original-array-from-doubled-array,py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-original-array-from-doubled-array,py
rename to problems/python/find-original-array-from-doubled-array,py
diff --git a/problems/find-peak-element.py b/problems/python/find-peak-element.py
old mode 100644
new mode 100755
similarity index 78%
rename from problems/find-peak-element.py
rename to problems/python/find-peak-element.py
index 5b9a8b3..aeb4726
--- a/problems/find-peak-element.py
+++ b/problems/python/find-peak-element.py
@@ -54,5 +54,24 @@ def findPeakElement(self, nums):
         return l
                 
                 
-            
+
+"""
+[l, r] is the possible range.
+Keep decreasing the range unsing binary search until l==r.
+Pay attention to
+m = l+(r-l+1)/2
+Sometimes you need m = l+(r-l)/2 to avoid infinite loop.
+"""
+class Solution(object):
+    def findPeakElement(self, nums):
+        l = 0
+        r = len(nums)-1
+        
+        while l<r:
+            m = l+(r-l+1)/2
+            if nums[m-1]<nums[m]:
+                l = m
+            else:
+                r = m-1
+        return l
         
\ No newline at end of file
diff --git a/problems/find-the-duplicate-number.py b/problems/python/find-the-duplicate-number.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/find-the-duplicate-number.py
rename to problems/python/find-the-duplicate-number.py
diff --git a/problems/first-bad-version.py b/problems/python/first-bad-version.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/first-bad-version.py
rename to problems/python/first-bad-version.py
diff --git a/problems/first-missing-positive.py b/problems/python/first-missing-positive.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/first-missing-positive.py
rename to problems/python/first-missing-positive.py
diff --git a/problems/first-unique-character-in-a-string.py b/problems/python/first-unique-character-in-a-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/first-unique-character-in-a-string.py
rename to problems/python/first-unique-character-in-a-string.py
diff --git a/problems/fizz-buzz.py b/problems/python/fizz-buzz.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/fizz-buzz.py
rename to problems/python/fizz-buzz.py
diff --git a/problems/flatten-binary-tree-to-linked-list.py b/problems/python/flatten-binary-tree-to-linked-list.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/flatten-binary-tree-to-linked-list.py
rename to problems/python/flatten-binary-tree-to-linked-list.py
diff --git a/problems/python/flip-binary-tree-to-match-preorder-traversal.py b/problems/python/flip-binary-tree-to-match-preorder-traversal.py
new file mode 100755
index 0000000..8727e28
--- /dev/null
+++ b/problems/python/flip-binary-tree-to-match-preorder-traversal.py
@@ -0,0 +1,23 @@
+class Solution(object):
+    def flipMatchVoyage(self, root, voyage):
+        def helper(node):
+            if not node: return
+            if node.val!=voyage[self.i]:
+                self.valid = False
+                return
+            
+            self.i += 1
+            if node.left and node.left.val!=voyage[self.i]:
+                self.ans.append(node.val)
+                helper(node.right)
+                helper(node.left)
+                
+            else:
+                helper(node.left)
+                helper(node.right)
+        
+        self.ans = []
+        self.i = 0
+        self.valid = True
+        helper(root)
+        return self.ans if self.valid else [-1]
\ No newline at end of file
diff --git a/problems/flip-string-to-monotone-increasing.py b/problems/python/flip-string-to-monotone-increasing.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/flip-string-to-monotone-increasing.py
rename to problems/python/flip-string-to-monotone-increasing.py
diff --git a/problems/flood-fill.py b/problems/python/flood-fill.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/flood-fill.py
rename to problems/python/flood-fill.py
diff --git a/problems/friend-circles.py b/problems/python/friend-circles.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/friend-circles.py
rename to problems/python/friend-circles.py
diff --git a/problems/fruit-into-baskets.py b/problems/python/fruit-into-baskets.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/fruit-into-baskets.py
rename to problems/python/fruit-into-baskets.py
diff --git a/problems/game-of-life.py b/problems/python/game-of-life.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/game-of-life.py
rename to problems/python/game-of-life.py
diff --git a/problems/generate-parentheses.py b/problems/python/generate-parentheses.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/generate-parentheses.py
rename to problems/python/generate-parentheses.py
diff --git a/problems/graph-valid-tree.py b/problems/python/graph-valid-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/graph-valid-tree.py
rename to problems/python/graph-valid-tree.py
diff --git a/problems/greatest-sum-divisible-by-three.py b/problems/python/greatest-sum-divisible-by-three.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/greatest-sum-divisible-by-three.py
rename to problems/python/greatest-sum-divisible-by-three.py
diff --git a/problems/group-anagrams.py b/problems/python/group-anagrams.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/group-anagrams.py
rename to problems/python/group-anagrams.py
diff --git a/problems/python/group-shifted-strings.py b/problems/python/group-shifted-strings.py
new file mode 100755
index 0000000..d5ac664
--- /dev/null
+++ b/problems/python/group-shifted-strings.py
@@ -0,0 +1,20 @@
+class Solution(object):
+    def groupStrings(self, strings):
+        def getHash(string):
+            h = ''
+            offset = getNumByChar(string[0])*-1
+            for c in string:
+                h += getCharByNum((getNumByChar(c)+offset) if (getNumByChar(c)+offset)>=0 else 26+(getNumByChar(c)+offset))
+            return h
+        
+        def getNumByChar(letter):
+            return ord(letter) - 97
+
+        def getCharByNum(pos):
+            return chr(pos + 97)
+        
+        groups = collections.defaultdict(list)
+        for string in strings:
+            h = getHash(string)
+            groups[h].append(string)
+        return groups.values()
\ No newline at end of file
diff --git a/problems/guess-number-higher-or-lower-ii.py b/problems/python/guess-number-higher-or-lower-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/guess-number-higher-or-lower-ii.py
rename to problems/python/guess-number-higher-or-lower-ii.py
diff --git a/problems/guess-number-higher-or-lower.py b/problems/python/guess-number-higher-or-lower.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/guess-number-higher-or-lower.py
rename to problems/python/guess-number-higher-or-lower.py
diff --git a/problems/guess-the-word.py b/problems/python/guess-the-word.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/guess-the-word.py
rename to problems/python/guess-the-word.py
diff --git a/problems/h-index-ii.py b/problems/python/h-index-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/h-index-ii.py
rename to problems/python/h-index-ii.py
diff --git a/problems/h-index.py b/problems/python/h-index.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/h-index.py
rename to problems/python/h-index.py
diff --git a/problems/hamming-distance.py b/problems/python/hamming-distance.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/hamming-distance.py
rename to problems/python/hamming-distance.py
diff --git a/problems/house-robber-ii.py b/problems/python/house-robber-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/house-robber-ii.py
rename to problems/python/house-robber-ii.py
diff --git a/problems/house-robber-iii.py b/problems/python/house-robber-iii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/house-robber-iii.py
rename to problems/python/house-robber-iii.py
diff --git a/problems/house-robber.py b/problems/python/house-robber.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/house-robber.py
rename to problems/python/house-robber.py
diff --git a/problems/implement-trie-prefix-tree.py b/problems/python/implement-trie-prefix-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/implement-trie-prefix-tree.py
rename to problems/python/implement-trie-prefix-tree.py
diff --git a/problems/increasing-triplet-subsequence.py b/problems/python/increasing-triplet-subsequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/increasing-triplet-subsequence.py
rename to problems/python/increasing-triplet-subsequence.py
diff --git a/problems/inorder-successor-in-bst-ii.py b/problems/python/inorder-successor-in-bst-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/inorder-successor-in-bst-ii.py
rename to problems/python/inorder-successor-in-bst-ii.py
diff --git a/problems/inorder-successor-in-bst.py b/problems/python/inorder-successor-in-bst.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/inorder-successor-in-bst.py
rename to problems/python/inorder-successor-in-bst.py
diff --git a/problems/insert-interval.py b/problems/python/insert-interval.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/insert-interval.py
rename to problems/python/insert-interval.py
diff --git a/problems/insert-into-a-binary-search-tree.py b/problems/python/insert-into-a-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/insert-into-a-binary-search-tree.py
rename to problems/python/insert-into-a-binary-search-tree.py
diff --git a/problems/python/insert-into-a-sorted-circular-linked-list.py b/problems/python/insert-into-a-sorted-circular-linked-list.py
new file mode 100755
index 0000000..9a4a067
--- /dev/null
+++ b/problems/python/insert-into-a-sorted-circular-linked-list.py
@@ -0,0 +1,42 @@
+class Solution(object):
+    def insert(self, random, insertVal):
+        def allValSame(node):
+            curr = node.next
+            while curr!=node:
+                if curr.val!=node.val: return False
+                curr = curr.next
+            return True
+                
+        newNode = Node(insertVal)
+        
+        #handle null linked list
+        if not random:
+            newNode.next = newNode
+            return newNode
+        
+        #handle linked list with val all the same
+        if allValSame(random):
+            temp = random.next
+            random.next = newNode
+            newNode.next = temp
+            return random
+        
+        #find head and tail, head is the min val node, tail is the max val node.
+        curr = random
+        while curr.val<=curr.next.val:
+            curr = curr.next
+        tail = curr
+        head = curr.next
+        
+        #insert new node
+        if insertVal>=tail.val or insertVal<=head.val:
+            tail.next = newNode
+            newNode.next = head
+        else:
+            curr = head
+            while not curr.val<=insertVal<=curr.next.val: curr = curr.next
+            temp = curr.next
+            curr.next = newNode
+            newNode.next = temp
+        
+        return random
\ No newline at end of file
diff --git a/problems/insertion-sort-list.py b/problems/python/insertion-sort-list.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/insertion-sort-list.py
rename to problems/python/insertion-sort-list.py
diff --git a/problems/integer-to-english-words.py b/problems/python/integer-to-english-words.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/integer-to-english-words.py
rename to problems/python/integer-to-english-words.py
diff --git a/problems/interleaving-string.py b/problems/python/interleaving-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/interleaving-string.py
rename to problems/python/interleaving-string.py
diff --git a/problems/intersection-of-two-arrays-ii.py b/problems/python/intersection-of-two-arrays-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/intersection-of-two-arrays-ii.py
rename to problems/python/intersection-of-two-arrays-ii.py
diff --git a/problems/intersection-of-two-arrays.py b/problems/python/intersection-of-two-arrays.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/intersection-of-two-arrays.py
rename to problems/python/intersection-of-two-arrays.py
diff --git a/problems/invert-binary-tree.py b/problems/python/invert-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/invert-binary-tree.py
rename to problems/python/invert-binary-tree.py
diff --git a/problems/is-graph-bipartite.py b/problems/python/is-graph-bipartite.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/is-graph-bipartite.py
rename to problems/python/is-graph-bipartite.py
diff --git a/problems/is-subsequence.py b/problems/python/is-subsequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/is-subsequence.py
rename to problems/python/is-subsequence.py
diff --git a/problems/isomorphic-strings.py b/problems/python/isomorphic-strings.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/isomorphic-strings.py
rename to problems/python/isomorphic-strings.py
diff --git a/problems/jewels-and-stones.py b/problems/python/jewels-and-stones.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/jewels-and-stones.py
rename to problems/python/jewels-and-stones.py
diff --git a/problems/jump-game.py b/problems/python/jump-game.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/jump-game.py
rename to problems/python/jump-game.py
diff --git a/problems/python/k-closest-points-to-origin.py b/problems/python/k-closest-points-to-origin.py
new file mode 100755
index 0000000..1f536c1
--- /dev/null
+++ b/problems/python/k-closest-points-to-origin.py
@@ -0,0 +1,131 @@
+class Solution(object):
+    def kClosest(self, points, k):
+        h = []
+        
+        for x, y in points:
+            d = (x**2+y**2)**0.5
+            if len(h)>=k and -h[0][0]>d:
+                heapq.heappop(h)
+                heapq.heappush(h, (-d, x, y))
+            elif len(h)>=k and -h[0][0]<=d:
+                pass
+            else:
+                heapq.heappush(h, (-d, x, y))
+        
+        return [(x, y) for _, x, y in h]
+
+
+"""
+1. Process `points` into `distances`.
+
+2. Binary search the "distance". For every distance:
+Split the elements in `distances` by distance
+Put the ones smaller to smaller.
+Put the ones larger to larger.
+If len(smaller)<=k, then all the elements in the smaller must belong to the `ans`, do the same thing to the larger.
+Else we ignore the larger and do the same thing to the smaller again.
+
+Time: O(N)
+The binary search range in average is N, N/2, N/4... = 2N
+Space: O(N)
+"""
+class Solution(object):
+    def kClosest(self, points, K):
+        #[1]
+        maxD = float('-inf')
+        minD = float('inf')
+        distances = []
+        for x, y in points:
+            distance = ((x**2+y**2)**0.5)
+            distances.append((distance, x, y))
+            maxD = max(maxD, distance)
+            minD = min(minD, distance)
+        
+        #[2]
+        ans = []
+        smaller = []
+        larger = []
+        while K>0:
+            #split distances into smaller and larger
+            distance = (maxD+minD)/2
+            for d, x, y in distances:
+                if d<=distance:
+                    smaller.append((d, x, y))
+                else:
+                    larger.append((d, x, y))
+            
+            if len(smaller)<=K:
+                ans += smaller
+                K -= len(smaller)
+                distances = larger
+                minD = distance
+                larger = []
+                smaller = []
+            else:
+                distances = smaller
+                maxD = distance
+                larger = []
+                smaller = []
+        
+        return [(x, y) for _, x, y in ans]
+
+
+
+"""
+Quick Select
+Time: O(N)
+Space: O(N), can be optimize to O(1).
+"""
+class Solution(object):
+    def kClosest(self, points, K):
+		"""
+		Start State:
+		i = s #next element after "SSS"s
+		t = s #unprocessed elements
+		j = e #next element after "LLLL"s
+
+		SSSPP?????LLL
+		i t   j
+
+		End State:
+		SSSPPPPPLLLLL
+		i   jt
+		"""
+        def quickSelect(distances, s, e, k):
+
+            pivot = distances[(s+e)/2][0]
+            i = s
+            j = e
+            t = s
+            
+            while t<=j:
+                if pivot<distances[t][0]:
+                    distances[t], distances[j] = distances[j], distances[t]
+                    j -= 1
+                elif pivot>distances[t][0]:
+                    distances[t], distances[i] = distances[i], distances[t]
+                    i += 1
+                    t += 1
+                else:
+                    t += 1
+            
+            if i-s>=k:
+                return quickSelect(distances, s, i, k)
+            elif j-s+1>=k:
+                return pivot
+            else:
+                return quickSelect(distances, t, e, k-(t-s))
+
+        distances = []
+        for x, y in points:
+            distance = ((x**2+y**2)**0.5)
+            distances.append((distance, x, y))
+        
+        kthSmallestDistance = quickSelect(distances, 0, len(distances)-1, K)
+        
+        ans = []
+        for d, x, y in distances:
+            if len(ans)==K: break
+            if d<=kthSmallestDistance: ans.append((x, y))
+        
+        return ans
\ No newline at end of file
diff --git a/problems/k-empty-slots.py b/problems/python/k-empty-slots.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/k-empty-slots.py
rename to problems/python/k-empty-slots.py
diff --git a/problems/keys-and-rooms.py b/problems/python/keys-and-rooms.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/keys-and-rooms.py
rename to problems/python/keys-and-rooms.py
diff --git a/problems/knight-dialer.py b/problems/python/knight-dialer.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/knight-dialer.py
rename to problems/python/knight-dialer.py
diff --git a/problems/knight-probability-in-chessboard.py b/problems/python/knight-probability-in-chessboard.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/knight-probability-in-chessboard.py
rename to problems/python/knight-probability-in-chessboard.py
diff --git a/problems/koko-eating-bananas.py b/problems/python/koko-eating-bananas.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/koko-eating-bananas.py
rename to problems/python/koko-eating-bananas.py
diff --git a/problems/kth-largest-element-in-an-array.py b/problems/python/kth-largest-element-in-an-array.py
old mode 100644
new mode 100755
similarity index 64%
rename from problems/kth-largest-element-in-an-array.py
rename to problems/python/kth-largest-element-in-an-array.py
index d12f59c..27c4b72
--- a/problems/kth-largest-element-in-an-array.py
+++ b/problems/python/kth-largest-element-in-an-array.py
@@ -63,4 +63,34 @@ def partition(A, l, r, p):
         
         k = len(nums)-k #redefine the problem to find the kth nums when sorted
         sortRange(nums, 0, len(nums)-1)
-        return nums[k]
\ No newline at end of file
+        return nums[k]
+
+
+#Quick Select
+class Solution(object):
+    def findKthLargest(self, nums, K):
+        def quickSelect(A, s, e, K):
+            pivot = A[(s+e)/2]
+            i = s
+            t = s
+            j = e
+            
+            while t<=j:
+                if A[t]<pivot:
+                    A[i], A[t] = A[t], A[i]
+                    i += 1
+                    t += 1
+                elif A[t]==pivot:
+                    t += 1
+                else:
+                    A[t], A[j] = A[j], A[t]
+                    j -= 1
+            
+            if e-j>=K:
+                return quickSelect(A, j+1, e, K)
+            elif e-i+1>=K:
+                return pivot
+            else:
+                return quickSelect(A, s, i-1, K-(e-(i-1)))
+            
+        return quickSelect(nums, 0, len(nums)-1, K)
\ No newline at end of file
diff --git a/problems/kth-smallest-element-in-a-bst.py b/problems/python/kth-smallest-element-in-a-bst.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/kth-smallest-element-in-a-bst.py
rename to problems/python/kth-smallest-element-in-a-bst.py
diff --git a/problems/kth-smallest-element-in-a-sorted-matrix.py b/problems/python/kth-smallest-element-in-a-sorted-matrix.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/kth-smallest-element-in-a-sorted-matrix.py
rename to problems/python/kth-smallest-element-in-a-sorted-matrix.py
diff --git a/problems/largest-1-bordered-square.py b/problems/python/largest-1-bordered-square.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/largest-1-bordered-square.py
rename to problems/python/largest-1-bordered-square.py
diff --git a/problems/largest-bst-subtree.py b/problems/python/largest-bst-subtree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/largest-bst-subtree.py
rename to problems/python/largest-bst-subtree.py
diff --git a/problems/largest-sum-of-averages.py b/problems/python/largest-sum-of-averages.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/largest-sum-of-averages.py
rename to problems/python/largest-sum-of-averages.py
diff --git a/problems/last-stone-weight-ii.py b/problems/python/last-stone-weight-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/last-stone-weight-ii.py
rename to problems/python/last-stone-weight-ii.py
diff --git a/problems/last-stone-weight.py b/problems/python/last-stone-weight.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/last-stone-weight.py
rename to problems/python/last-stone-weight.py
diff --git a/problems/least-number-of-unique-integers-after-k-removals.py b/problems/python/least-number-of-unique-integers-after-k-removals.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/least-number-of-unique-integers-after-k-removals.py
rename to problems/python/least-number-of-unique-integers-after-k-removals.py
diff --git a/problems/letter-case-permutation.py b/problems/python/letter-case-permutation.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/letter-case-permutation.py
rename to problems/python/letter-case-permutation.py
diff --git a/problems/letter-combinations-of-a-phone-number.py b/problems/python/letter-combinations-of-a-phone-number.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/letter-combinations-of-a-phone-number.py
rename to problems/python/letter-combinations-of-a-phone-number.py
diff --git a/problems/license-key-formatting.py b/problems/python/license-key-formatting.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/license-key-formatting.py
rename to problems/python/license-key-formatting.py
diff --git a/problems/linked-list-cycle-ii.py b/problems/python/linked-list-cycle-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/linked-list-cycle-ii.py
rename to problems/python/linked-list-cycle-ii.py
diff --git a/problems/linked-list-cycle.py b/problems/python/linked-list-cycle.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/linked-list-cycle.py
rename to problems/python/linked-list-cycle.py
diff --git a/problems/linked-list-random-node.py b/problems/python/linked-list-random-node.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/linked-list-random-node.py
rename to problems/python/linked-list-random-node.py
diff --git a/problems/python/logger-rate-limiter.py b/problems/python/logger-rate-limiter.py
new file mode 100755
index 0000000..0f5f7ad
--- /dev/null
+++ b/problems/python/logger-rate-limiter.py
@@ -0,0 +1,32 @@
+class Logger(object):
+    def __init__(self):
+        self.log = collections.Counter() #store the latest timestamp
+
+    def shouldPrintMessage(self, timestamp, message):
+        if message not in self.log or self.log[message]+10<=timestamp:
+            self.log[message] = timestamp
+            return True
+        else:
+            return False
+
+
+
+class Logger(object):
+
+    def __init__(self):
+        #stores the messages within 10 seconds
+        self.q = collections.deque()
+        self.set = set()
+        
+
+    def shouldPrintMessage(self, timestamp, message):
+        while self.q and timestamp-self.q[0][0]>=10:
+            time, msg = self.q.popleft()
+            self.set.remove(msg)
+        
+        if message not in self.set:
+            self.q.append((timestamp, message))
+            self.set.add(message)
+            return True
+        else:
+            return False
\ No newline at end of file
diff --git a/problems/longest-common-prefix.py b/problems/python/longest-common-prefix.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-common-prefix.py
rename to problems/python/longest-common-prefix.py
diff --git a/problems/longest-common-subsequence.py b/problems/python/longest-common-subsequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-common-subsequence.py
rename to problems/python/longest-common-subsequence.py
diff --git a/problems/longest-consecutive-sequence.py b/problems/python/longest-consecutive-sequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-consecutive-sequence.py
rename to problems/python/longest-consecutive-sequence.py
diff --git a/problems/python/longest-increasing-path-in-a-matrix.py b/problems/python/longest-increasing-path-in-a-matrix.py
new file mode 100755
index 0000000..cd446d9
--- /dev/null
+++ b/problems/python/longest-increasing-path-in-a-matrix.py
@@ -0,0 +1,31 @@
+class Solution(object):
+    def longestIncreasingPath(self, matrix):
+        def getLongest(i, j):
+            if (i, j) in longest: return longest[(i, j)]
+            l = 1
+
+            #call getLongest to the neighbors that are larger than itself.
+            if i+1<M and matrix[i][j]<matrix[i+1][j]:
+                l = max(l, 1+getLongest(i+1, j))
+            if i-1>=0 and matrix[i][j]<matrix[i-1][j]:
+                l = max(l, 1+getLongest(i-1, j))
+            if j+1<N and matrix[i][j]<matrix[i][j+1]:
+                l = max(l, 1+getLongest(i, j+1))
+            if j-1>=0 and matrix[i][j]<matrix[i][j-1]:
+                l = max(l, 1+getLongest(i, j-1))
+            
+            longest[(i, j)] = l
+            self.ans = max(self.ans, l)
+            return l
+
+        M = len(matrix)
+        N = len(matrix[0])
+        
+        longest = {}
+        self.ans = float('-inf')
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                getLongest(i, j)
+                
+        return self.ans
\ No newline at end of file
diff --git a/problems/longest-increasing-subsequence.py b/problems/python/longest-increasing-subsequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-increasing-subsequence.py
rename to problems/python/longest-increasing-subsequence.py
diff --git a/problems/longest-palindromic-subsequence.py b/problems/python/longest-palindromic-subsequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-palindromic-subsequence.py
rename to problems/python/longest-palindromic-subsequence.py
diff --git a/problems/longest-palindromic-substring.py b/problems/python/longest-palindromic-substring.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-palindromic-substring.py
rename to problems/python/longest-palindromic-substring.py
diff --git a/problems/longest-repeating-character-replacement.py b/problems/python/longest-repeating-character-replacement.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-repeating-character-replacement.py
rename to problems/python/longest-repeating-character-replacement.py
diff --git a/problems/longest-string-chain.py b/problems/python/longest-string-chain.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-string-chain.py
rename to problems/python/longest-string-chain.py
diff --git a/problems/longest-substring-with-at-least-k-repeating-characters.py b/problems/python/longest-substring-with-at-least-k-repeating-characters.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-substring-with-at-least-k-repeating-characters.py
rename to problems/python/longest-substring-with-at-least-k-repeating-characters.py
diff --git a/problems/longest-substring-without-repeating-characters.py b/problems/python/longest-substring-without-repeating-characters.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-substring-without-repeating-characters.py
rename to problems/python/longest-substring-without-repeating-characters.py
diff --git a/problems/longest-univalue-path.py b/problems/python/longest-univalue-path.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/longest-univalue-path.py
rename to problems/python/longest-univalue-path.py
diff --git a/problems/lowest-common-ancestor-of-a-binary-search-tree.py b/problems/python/lowest-common-ancestor-of-a-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/lowest-common-ancestor-of-a-binary-search-tree.py
rename to problems/python/lowest-common-ancestor-of-a-binary-search-tree.py
diff --git a/problems/lowest-common-ancestor-of-a-binary-search.py b/problems/python/lowest-common-ancestor-of-a-binary-search.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/lowest-common-ancestor-of-a-binary-search.py
rename to problems/python/lowest-common-ancestor-of-a-binary-search.py
diff --git a/problems/python/lowest-common-ancestor-of-a-binary-tree-ii.py b/problems/python/lowest-common-ancestor-of-a-binary-tree-ii.py
new file mode 100755
index 0000000..8f07177
--- /dev/null
+++ b/problems/python/lowest-common-ancestor-of-a-binary-tree-ii.py
@@ -0,0 +1,17 @@
+class Solution(object):
+    def __init__(self):
+        self.ans = None
+        
+    def lowestCommonAncestor(self, root, p, q):
+        def dfs(node):
+            if not node: return 0
+            
+            count = 0
+            if node is p or node is q: count += 1
+            count += dfs(node.left)
+            count += dfs(node.right)
+            if count>=2 and not self.ans: self.ans = node
+            return count
+        
+        dfs(root)
+        return self.ans
diff --git a/problems/python/lowest-common-ancestor-of-a-binary-tree-iii.py b/problems/python/lowest-common-ancestor-of-a-binary-tree-iii.py
new file mode 100755
index 0000000..cfd14f7
--- /dev/null
+++ b/problems/python/lowest-common-ancestor-of-a-binary-tree-iii.py
@@ -0,0 +1,56 @@
+"""
+Time: O(H), H is the height of the tree.
+Space: O(1)
+"""
+class Solution(object):
+    def lowestCommonAncestor(self, p, q):
+        ancestorP = set()
+        ancestorQ = set()
+        
+        temp = p
+        while temp:
+            ancestorP.add(temp)
+            temp = temp.parent
+        
+        temp = q
+        while temp:
+            ancestorQ.add(temp)
+            temp = temp.parent
+        
+        commonAncestor = ancestorQ.intersection(ancestorP)
+        temp = q
+        while temp:
+            if temp in commonAncestor: return temp 
+            temp = temp.parent
+        return None
+
+
+"""
+Time: O(LogN)
+Space: O(LogN)
+
+Looking from backward, parents1 and parents2 will be the same at first, since they must have a common ancestor.
+Find the last the same parents.
+"""
+class Solution(object):
+    def lowestCommonAncestor(self, p, q):
+        parents1 = []
+        parents2 = []
+        
+        curr = p
+        while curr:
+            parents1.append(curr)
+            curr = curr.parent
+        
+        curr = q
+        while curr:
+            parents2.append(curr)
+            curr = curr.parent
+        
+        i = len(parents1)-1
+        j = len(parents2)-1
+        while i>=0 and j>=0 and parents1[i]==parents2[j]:
+            i -= 1
+            j -= 1
+        return parents1[i+1]
+    
diff --git a/problems/python/lowest-common-ancestor-of-a-binary-tree-iv.py b/problems/python/lowest-common-ancestor-of-a-binary-tree-iv.py
new file mode 100755
index 0000000..f7458a3
--- /dev/null
+++ b/problems/python/lowest-common-ancestor-of-a-binary-tree-iv.py
@@ -0,0 +1,18 @@
+class Solution(object):
+    def __init__(self):
+        self.ans = None
+        
+    def lowestCommonAncestor(self, root, nodes):
+        def dfs(node):
+            if not node: return 0
+            
+            count = 0
+            if node in nodes: count += 1
+            count += dfs(node.left)
+            count += dfs(node.right)
+            if count>=len(nodes) and not self.ans: self.ans = node    
+            return count
+        
+        nodes = set(nodes)
+        dfs(root)
+        return self.ans
\ No newline at end of file
diff --git a/problems/lowest-common-ancestor-of-a-binary-tree.py b/problems/python/lowest-common-ancestor-of-a-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/lowest-common-ancestor-of-a-binary-tree.py
rename to problems/python/lowest-common-ancestor-of-a-binary-tree.py
diff --git a/problems/python/lowest-common-ancestor-of-deepest-leaves.py b/problems/python/lowest-common-ancestor-of-deepest-leaves.py
new file mode 100755
index 0000000..cffade3
--- /dev/null
+++ b/problems/python/lowest-common-ancestor-of-deepest-leaves.py
@@ -0,0 +1,41 @@
+class Solution(object):
+    def __init__(self):
+        self.ans = None
+        
+    def lcaDeepestLeaves(self, root):
+        def checkCount(node, deepestNode):
+            if not node:
+                count = 0
+                if count==len(deepestNode) and not self.ans: self.ans = node
+                return 0
+            
+            if node in deepestNode:
+                count = 1
+                if count==len(deepestNode) and not self.ans: self.ans = node
+                return count
+            
+            leftCount = checkCount(node.left, deepestNode)
+            rightCount = checkCount(node.right, deepestNode)
+            
+            if leftCount+rightCount==len(deepestNode) and not self.ans: self.ans = node
+            return leftCount+rightCount
+            
+        q = collections.deque([(root, 0)])
+        q2 = collections.deque()
+        deepestNode = set([node for node, h in q])
+        
+        while q:
+            node, d = q.popleft()
+            if node.left: q2.append((node.left, d+1))
+            if node.right: q2.append((node.right, d+1))
+            if not q:
+                q = q2
+                if q: deepestNode = set([node for node, h in q])
+                q2 = collections.deque()
+        
+        checkCount(root, deepestNode)
+        return self.ans
+        
+                
+            
+        
\ No newline at end of file
diff --git a/problems/lru-cache.py b/problems/python/lru-cache.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/lru-cache.py
rename to problems/python/lru-cache.py
diff --git a/problems/majority-element-ii.py b/problems/python/majority-element-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/majority-element-ii.py
rename to problems/python/majority-element-ii.py
diff --git a/problems/majority-element.py b/problems/python/majority-element.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/majority-element.py
rename to problems/python/majority-element.py
diff --git a/problems/python/making-a-large-island.py b/problems/python/making-a-large-island.py
new file mode 100755
index 0000000..215aa2a
--- /dev/null
+++ b/problems/python/making-a-large-island.py
@@ -0,0 +1,51 @@
+"""
+For each "island" asign them a group id. Also calculate the group's size.
+Iterate all the zeros, update the ans.
+
+Time:O(MN)
+Space: O(MN) in the worst case.
+"""
+class Solution(object):
+    def largestIsland(self, grid):
+        def isValid(i, j, M, N):
+            return 0<=i<M and 0<=j<N
+        
+        def dfs(i, j, groupId):
+            if not isValid(i, j, M, N): return
+            if grid[i][j]!=1: return
+            grid[i][j] = groupId
+            groupIdToSize[groupId] += 1
+            for iNext, jNext in [(i+1, j), (i-1, j), (i, j-1), (i, j+1)]:
+                dfs(iNext, jNext, groupId)
+
+        M = len(grid)
+        N = len(grid[0])
+        
+        zeros = []
+        groupIdToSize = {}
+        groupId = 2
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]==1:
+                    groupIdToSize[groupId] = 0
+                    dfs(i, j, groupId)
+                    groupId += 1
+                elif grid[i][j]==0:
+                    zeros.append((i, j))
+                    
+        ans = max(groupIdToSize.values()) if groupIdToSize else 0
+        
+        for i, j in zeros:
+            neiGroupId = set()
+            neiSize = 0
+            for iNext, jNext in [(i+1, j), (i-1, j), (i, j-1), (i, j+1)]:
+                if not isValid(iNext, jNext, M, N): continue
+                if grid[iNext][jNext]>1:
+                    neiGroupId.add(grid[iNext][jNext])
+            
+            for groupId in list(neiGroupId):
+                neiSize += groupIdToSize[groupId]
+            
+            ans = max(ans, 1+neiSize)
+        
+        return ans
\ No newline at end of file
diff --git a/problems/max-area-of-island.py b/problems/python/max-area-of-island.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/max-area-of-island.py
rename to problems/python/max-area-of-island.py
diff --git a/problems/max-consecutive-ones-iii.py b/problems/python/max-consecutive-ones-iii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/max-consecutive-ones-iii.py
rename to problems/python/max-consecutive-ones-iii.py
diff --git a/problems/max-stack.py b/problems/python/max-stack.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/max-stack.py
rename to problems/python/max-stack.py
diff --git a/problems/max-sum-of-rectangle-no-larger-than-k.py b/problems/python/max-sum-of-rectangle-no-larger-than-k.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/max-sum-of-rectangle-no-larger-than-k.py
rename to problems/python/max-sum-of-rectangle-no-larger-than-k.py
diff --git a/problems/python/maximal-square.py b/problems/python/maximal-square.py
new file mode 100755
index 0000000..9e6711b
--- /dev/null
+++ b/problems/python/maximal-square.py
@@ -0,0 +1,33 @@
+class Solution(object):
+    def maximalSquare(self, grid):
+        if not grid or not grid[0]: return 
+        M, N = len(grid), len(grid[0])
+        
+        dp = [[0 for _ in xrange(N+1)] for _ in xrange(M+1)]
+        ans = 0
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]=='1':
+                    dp[i+1][j+1] = min(dp[i][j], dp[i][j+1], dp[i+1][j])+1
+                    ans = max(ans, dp[i+1][j+1])
+        return ans**2
+
+
+
+class Solution(object):
+    def maximalSquare(self, matrix):
+        """
+        dp[i][j] := maximal square length with matrix[i-1][j-1] at the bottom right corner in the square
+        """
+        ans = 0
+        N = len(matrix)
+        M = len(matrix[0])
+        
+        dp = [[0 for _ in xrange(M+1)] for _ in xrange(N+1)]
+        
+        for i in xrange(1, N+1):
+            for j in xrange(1, M+1):
+                if matrix[i-1][j-1]=='1':
+                    dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1])+1
+                    ans = max(ans, dp[i][j]**2)
+        return ans
\ No newline at end of file
diff --git a/problems/maximum-average-subtree.py b/problems/python/maximum-average-subtree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-average-subtree.py
rename to problems/python/maximum-average-subtree.py
diff --git a/problems/python/maximum-compatibility-score-sum.py b/problems/python/maximum-compatibility-score-sum.py
new file mode 100755
index 0000000..a0f744c
--- /dev/null
+++ b/problems/python/maximum-compatibility-score-sum.py
@@ -0,0 +1,44 @@
+"""
+Time: O(ELogE), E is the edge of the graph.
+Note that state[i] means if the ith student is matched or not. (for example M=4, 0000, 0010, 0111, 1111...)
+2^M is the number of states. So in this case E will be 2^M x M.
+
+Space: O(2^M)
+"""
+class Solution(object):
+    def maxCompatibilitySum(self, students, mentors):
+        M = len(students)
+        N = len(students[0])
+
+        #initialize reverseScores
+        reverseScores = [[0]*M for _ in xrange(M)]
+        for i in xrange(M):
+            for j in xrange(M):
+                reverseScore = 0
+                for k in xrange(N):
+                    if students[i][k]!=mentors[j][k]:
+                        reverseScore += 1
+                reverseScores[i][j] = reverseScore
+        
+        #Dijkstra
+        startState = '0'*M
+        endState = '1'*M
+        visited = set()
+        pq = [(0, startState)]
+        
+        while pq:
+            cost, state = heapq.heappop(pq)
+            if state in visited: continue
+            visited.add(state)
+            
+            if state==endState: return M*N-cost
+            
+            j = state.count('1')
+            for i in xrange(M):
+                if state[i]=='1': continue
+                
+                nextState = state[:i]+'1'+state[i+1:]
+                if nextState in visited: continue
+                heapq.heappush(pq, (cost+reverseScores[i][j], nextState))
+        
+        return -1
\ No newline at end of file
diff --git a/problems/maximum-depth-of-binary-tree.py b/problems/python/maximum-depth-of-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-depth-of-binary-tree.py
rename to problems/python/maximum-depth-of-binary-tree.py
diff --git a/problems/maximum-gap.py b/problems/python/maximum-gap.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-gap.py
rename to problems/python/maximum-gap.py
diff --git a/problems/maximum-length-of-repeated-subarray.py b/problems/python/maximum-length-of-repeated-subarray.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-length-of-repeated-subarray.py
rename to problems/python/maximum-length-of-repeated-subarray.py
diff --git a/problems/maximum-number-of-events-that-can-be-attended.py b/problems/python/maximum-number-of-events-that-can-be-attended.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-number-of-events-that-can-be-attended.py
rename to problems/python/maximum-number-of-events-that-can-be-attended.py
diff --git a/problems/maximum-number-of-points-with-cost.py b/problems/python/maximum-number-of-points-with-cost.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-number-of-points-with-cost.py
rename to problems/python/maximum-number-of-points-with-cost.py
diff --git a/problems/maximum-number-of-visible-points.py b/problems/python/maximum-number-of-visible-points.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-number-of-visible-points.py
rename to problems/python/maximum-number-of-visible-points.py
diff --git a/problems/maximum-product-of-three-numbers.py b/problems/python/maximum-product-of-three-numbers.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-product-of-three-numbers.py
rename to problems/python/maximum-product-of-three-numbers.py
diff --git a/problems/maximum-product-subarray.py b/problems/python/maximum-product-subarray.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-product-subarray.py
rename to problems/python/maximum-product-subarray.py
diff --git a/problems/maximum-subarray-sum-with-one-deletion.py b/problems/python/maximum-subarray-sum-with-one-deletion.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-subarray-sum-with-one-deletion.py
rename to problems/python/maximum-subarray-sum-with-one-deletion.py
diff --git a/problems/maximum-subarray.py b/problems/python/maximum-subarray.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-subarray.py
rename to problems/python/maximum-subarray.py
diff --git a/problems/python/maximum-swap.py b/problems/python/maximum-swap.py
new file mode 100755
index 0000000..ffca66a
--- /dev/null
+++ b/problems/python/maximum-swap.py
@@ -0,0 +1,23 @@
+"""
+1. Generate positions. Storing the mapping between number to indices.
+2. Iterate from left, for each n1, find the largest number larger than n1 (searching from 9, 8, 7 to n1+1).
+3. Since we need to find the max output. There might be multiple the same number, we need to find the index of the rightest number.
+4. Remove n1 when it is done. Because right of the n1 should not consider it anymore.
+"""
+class Solution(object):
+    def maximumSwap(self, num):
+        numList = [int(n) for n in str(num)]
+        positions = collections.defaultdict(list)
+        for i, n in enumerate(numList): positions[n].append(i) #[1]
+        
+        i = 0
+        for i, n1 in enumerate(numList): #[2]
+            n1 = numList[i]
+            for n2 in xrange(9, n1, -1): 
+                if n2 in positions and len(positions[n2])>0:
+                    j = positions[n2][-1] #[3]
+                    numList[i], numList[j] = numList[j], numList[i]
+                    return int(''.join([str(n) for n in numList]))
+            positions[n1].pop(0) #[4]
+            
+        return num
\ No newline at end of file
diff --git a/problems/maximum-units-on-a-truck.py b/problems/python/maximum-units-on-a-truck.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/maximum-units-on-a-truck.py
rename to problems/python/maximum-units-on-a-truck.py
diff --git a/problems/median-of-two-sorted-arrays.py b/problems/python/median-of-two-sorted-arrays.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/median-of-two-sorted-arrays.py
rename to problems/python/median-of-two-sorted-arrays.py
diff --git a/problems/meeting-rooms-ii.py b/problems/python/meeting-rooms-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/meeting-rooms-ii.py
rename to problems/python/meeting-rooms-ii.py
diff --git a/problems/meeting-rooms.py b/problems/python/meeting-rooms.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/meeting-rooms.py
rename to problems/python/meeting-rooms.py
diff --git a/problems/merge-intervals.py b/problems/python/merge-intervals.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/merge-intervals.py
rename to problems/python/merge-intervals.py
diff --git a/problems/merge-k-sorted-lists.py b/problems/python/merge-k-sorted-lists.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/merge-k-sorted-lists.py
rename to problems/python/merge-k-sorted-lists.py
diff --git a/problems/merge-sorted-array.py b/problems/python/merge-sorted-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/merge-sorted-array.py
rename to problems/python/merge-sorted-array.py
diff --git a/problems/merge-two-sorted-lists.py b/problems/python/merge-two-sorted-lists.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/merge-two-sorted-lists.py
rename to problems/python/merge-two-sorted-lists.py
diff --git a/problems/min-cost-climbing-stairs.py b/problems/python/min-cost-climbing-stairs.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/min-cost-climbing-stairs.py
rename to problems/python/min-cost-climbing-stairs.py
diff --git a/problems/min-stack.py b/problems/python/min-stack.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/min-stack.py
rename to problems/python/min-stack.py
diff --git a/problems/minimize-malware-spread.py b/problems/python/minimize-malware-spread.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimize-malware-spread.py
rename to problems/python/minimize-malware-spread.py
diff --git a/problems/minimum-absolute-difference-in-bst.py b/problems/python/minimum-absolute-difference-in-bst.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-absolute-difference-in-bst.py
rename to problems/python/minimum-absolute-difference-in-bst.py
diff --git a/problems/minimum-ascii-delete-sum-for-two-strings.py b/problems/python/minimum-ascii-delete-sum-for-two-strings.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-ascii-delete-sum-for-two-strings.py
rename to problems/python/minimum-ascii-delete-sum-for-two-strings.py
diff --git a/problems/minimum-cost-to-connect-sticks.py b/problems/python/minimum-cost-to-connect-sticks.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-cost-to-connect-sticks.py
rename to problems/python/minimum-cost-to-connect-sticks.py
diff --git a/problems/minimum-cost-to-hire-k-workers.py b/problems/python/minimum-cost-to-hire-k-workers.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-cost-to-hire-k-workers.py
rename to problems/python/minimum-cost-to-hire-k-workers.py
diff --git a/problems/python/minimum-cost-to-make-at-least-one-valid-path-in-a-grid.py b/problems/python/minimum-cost-to-make-at-least-one-valid-path-in-a-grid.py
new file mode 100755
index 0000000..2188f4a
--- /dev/null
+++ b/problems/python/minimum-cost-to-make-at-least-one-valid-path-in-a-grid.py
@@ -0,0 +1,32 @@
+class Solution(object):
+    def minCost(self, grid):
+        pq = [(0, False, 0, 0, 0)]
+        visited = set()
+        M = len(grid)
+        N = len(grid[0])
+        
+        while pq:
+            cost, modified, direction, x, y = heapq.heappop(pq)
+            if x<0 or x>=M or y<0 or y>=N: continue
+            if (direction, x, y) in visited: continue
+            visited.add((direction, x, y))
+            
+            if x==M-1 and y==N-1: return cost
+            
+            if direction==0: direction = grid[x][y]
+
+            if direction==1:
+                heapq.heappush(pq, (cost, False, 0, x, y+1))
+            elif direction==2:
+                heapq.heappush(pq, (cost, False, 0, x, y-1))
+            elif direction==3:
+                heapq.heappush(pq, (cost, False, 0, x+1, y))
+            elif direction==4:
+                heapq.heappush(pq, (cost, False, 0, x-1, y))
+        
+            if not modified:    
+                for d in [1,2,3,4]:
+                    if d==grid[x][y]: continue
+                    heapq.heappush(pq, (cost+1, True, d, x, y))
+                            
+        return float('inf')
\ No newline at end of file
diff --git a/problems/python/minimum-cost-to-reach-city-with-discounts.py b/problems/python/minimum-cost-to-reach-city-with-discounts.py
new file mode 100755
index 0000000..93205f3
--- /dev/null
+++ b/problems/python/minimum-cost-to-reach-city-with-discounts.py
@@ -0,0 +1,25 @@
+class Solution(object):
+    def minimumCost(self, n, highways, discounts):
+        pq = [(0, discounts, 0)]
+        visited = set()
+        
+        adj = collections.defaultdict(list)
+        for city1, city2, toll in highways:
+            adj[city1].append((city2, toll))
+            adj[city2].append((city1, toll))
+        
+        
+        while pq:
+            toll, d, city = heapq.heappop(pq)
+            if (d, city) in visited: continue
+            visited.add((d, city))
+            
+            if city==n-1: return toll
+            
+            for nei, toll2 in adj[city]:
+                if (d, nei) not in visited:
+                    heapq.heappush(pq, (toll+toll2, d, nei))
+                if d>0 and (d-1, nei) not in visited:
+                    heapq.heappush(pq, (toll+toll2/2, d-1, nei))    
+        
+        return -1
\ No newline at end of file
diff --git a/problems/minimum-depth-of-binary-tree.py b/problems/python/minimum-depth-of-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-depth-of-binary-tree.py
rename to problems/python/minimum-depth-of-binary-tree.py
diff --git a/problems/minimum-difficulty-of-a-job-schedule.py b/problems/python/minimum-difficulty-of-a-job-schedule.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-difficulty-of-a-job-schedule.py
rename to problems/python/minimum-difficulty-of-a-job-schedule.py
diff --git a/problems/minimum-falling-path-sum-ii.py b/problems/python/minimum-falling-path-sum-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-falling-path-sum-ii.py
rename to problems/python/minimum-falling-path-sum-ii.py
diff --git a/problems/minimum-knight-moves.py b/problems/python/minimum-knight-moves.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-knight-moves.py
rename to problems/python/minimum-knight-moves.py
diff --git a/problems/python/minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.py b/problems/python/minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.py
new file mode 100755
index 0000000..5559c80
--- /dev/null
+++ b/problems/python/minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.py
@@ -0,0 +1,42 @@
+class Solution(object):
+    def minFlips(self, mat):
+        def flip(mat, m, n):
+            mat[m][n] = 0 if mat[m][n]==1 else 1
+            if m+1<len(mat): mat[m+1][n] = 0 if mat[m+1][n]==1 else 1
+            if n+1<len(mat[0]): mat[m][n+1] = 0 if mat[m][n+1]==1 else 1
+            if m-1>=0: mat[m-1][n] = 0 if mat[m-1][n]==1 else 1
+            if n-1>=0: mat[m][n-1] = 0 if mat[m][n-1]==1 else 1
+            
+        def check(mat, state):
+            for i, b in enumerate(state):
+                if b=='1':
+                    m = i/len(mat[0])
+                    n = i%len(mat[0])
+                    flip(mat, m, n)
+            
+            for i in xrange(len(mat)):
+                for j in xrange(len(mat[0])):
+                    if mat[i][j]==1: return False
+            
+            return True
+                    
+        
+        M = len(mat)
+        N = len(mat[0])
+        q = collections.deque(['0'*(M*N)])
+        visited = set()
+        
+        while q:
+            state = q.popleft()
+            if state in visited: continue
+            visited.add(state)
+            
+            if check([row[:] for row in mat], state): return state.count('1')
+            
+            for i in xrange(len(state)):
+                if state[i]=='1': continue
+                nextState = state[:i] + '1' +state[i+1:]
+                q.append(nextState)
+                
+        return -1
+    
\ No newline at end of file
diff --git a/problems/minimum-path-sum.py b/problems/python/minimum-path-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-path-sum.py
rename to problems/python/minimum-path-sum.py
diff --git a/problems/minimum-score-triangulation-of-polygon.py b/problems/python/minimum-score-triangulation-of-polygon.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-score-triangulation-of-polygon.py
rename to problems/python/minimum-score-triangulation-of-polygon.py
diff --git a/problems/minimum-size-subarray-sum.py b/problems/python/minimum-size-subarray-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-size-subarray-sum.py
rename to problems/python/minimum-size-subarray-sum.py
diff --git a/problems/minimum-swaps-to-group-all-1s-together.py b/problems/python/minimum-swaps-to-group-all-1s-together.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-swaps-to-group-all-1s-together.py
rename to problems/python/minimum-swaps-to-group-all-1s-together.py
diff --git a/problems/minimum-swaps-to-make-sequences-increasing.py b/problems/python/minimum-swaps-to-make-sequences-increasing.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-swaps-to-make-sequences-increasing.py
rename to problems/python/minimum-swaps-to-make-sequences-increasing.py
diff --git a/problems/python/minimum-time-difference.py b/problems/python/minimum-time-difference.py
new file mode 100755
index 0000000..1645692
--- /dev/null
+++ b/problems/python/minimum-time-difference.py
@@ -0,0 +1,32 @@
+"""
+Time: O(1440)
+Space: O(1440)
+"""
+class Solution(object):
+    def findMinDifference(self, timeStrings):
+        def timeStringToMinutes(timeString):
+            time = timeString.split(':')
+            h = int(time[0])
+            m = int(time[1])
+            return h*60+m
+        
+        ans = float('inf')
+        minTime = float('inf')
+        maxTime = float('-inf')
+        timeSet = set()
+        for timeString in timeStrings:
+            t = timeStringToMinutes(timeString)
+            if t in timeSet: return 0
+            minTime = min(minTime, t)
+            maxTime = max(maxTime, t)
+            timeSet.add(t)
+        
+        
+        prev = None
+        for t in xrange(minTime, maxTime+1):
+            if t not in timeSet: continue
+            if prev!=None: ans = min(ans, t-prev)
+            prev = t
+        
+        ans = min(ans, 1440+minTime-maxTime) #compare minTime and maxTime
+        return ans
\ No newline at end of file
diff --git a/problems/minimum-window-substring.py b/problems/python/minimum-window-substring.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/minimum-window-substring.py
rename to problems/python/minimum-window-substring.py
diff --git a/problems/python/minimum-xor-sum-of-two-arrays.py b/problems/python/minimum-xor-sum-of-two-arrays.py
new file mode 100755
index 0000000..7c3a195
--- /dev/null
+++ b/problems/python/minimum-xor-sum-of-two-arrays.py
@@ -0,0 +1,24 @@
+"""
+state[i] := nums1[i] has been matched.
+"""
+class Solution(object):
+    def minimumXORSum(self, nums1, nums2):
+        N = len(nums1)
+        
+        pq = [(0, '0'*N)]
+        visited = set()
+        while pq:
+            s, state = heapq.heappop(pq)
+            if state in visited: continue
+            visited.add(state)
+            
+            j = state.count('1')
+            if j==N: return s
+            
+            for i in xrange(N):
+                if state[i]=='1': continue
+                nextState = state[:i]+'1'+state[i+1:]
+                if nextState in visited: continue
+                heapq.heappush(pq, ((s+(nums1[i]^nums2[j-1]), nextState)))
+        
+        return float('inf')
\ No newline at end of file
diff --git a/problems/missing-number.py b/problems/python/missing-number.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/missing-number.py
rename to problems/python/missing-number.py
diff --git a/problems/most-frequent-subtree-sum.py b/problems/python/most-frequent-subtree-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/most-frequent-subtree-sum.py
rename to problems/python/most-frequent-subtree-sum.py
diff --git a/problems/most-stones-removed-with-same-row-or-column.py b/problems/python/most-stones-removed-with-same-row-or-column.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/most-stones-removed-with-same-row-or-column.py
rename to problems/python/most-stones-removed-with-same-row-or-column.py
diff --git a/problems/move-zeroes.py b/problems/python/move-zeroes.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/move-zeroes.py
rename to problems/python/move-zeroes.py
diff --git a/problems/moving-average-from-data-stream.py b/problems/python/moving-average-from-data-stream.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/moving-average-from-data-stream.py
rename to problems/python/moving-average-from-data-stream.py
diff --git a/problems/my-calendar-ii.py b/problems/python/my-calendar-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/my-calendar-ii.py
rename to problems/python/my-calendar-ii.py
diff --git a/problems/n-ary-tree-level-order-traversal.py b/problems/python/n-ary-tree-level-order-traversal.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/n-ary-tree-level-order-traversal.py
rename to problems/python/n-ary-tree-level-order-traversal.py
diff --git a/problems/n-ary-tree-postorder-traversal.py b/problems/python/n-ary-tree-postorder-traversal.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/n-ary-tree-postorder-traversal.py
rename to problems/python/n-ary-tree-postorder-traversal.py
diff --git a/problems/n-ary-tree-preorder-traversal.py b/problems/python/n-ary-tree-preorder-traversal.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/n-ary-tree-preorder-traversal.py
rename to problems/python/n-ary-tree-preorder-traversal.py
diff --git a/problems/nested-list-weight-sum.py b/problems/python/nested-list-weight-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/nested-list-weight-sum.py
rename to problems/python/nested-list-weight-sum.py
diff --git a/problems/network-delay-time.py b/problems/python/network-delay-time.py
old mode 100644
new mode 100755
similarity index 58%
rename from problems/network-delay-time.py
rename to problems/python/network-delay-time.py
index 8098a31..aa67bb0
--- a/problems/network-delay-time.py
+++ b/problems/python/network-delay-time.py
@@ -118,12 +118,96 @@ def networkDelayTime(self, times, n, k):
             
         
 
+"""
+Dijkstra BFS+Priority Queue Implementation
+Time: O(ELogE), E is the edges count in the graph.
+"""
+class Solution(object):
+    def networkDelayTime(self, times, N, K):
+        ans = -1 #max time from K to any
+        visited = set()
+        pq = [(0, K)] #[(node's distance to K, node)]
+        
+        #construct adjacency list
+        adj = collections.defaultdict(list)
+        for u, v, w in times:
+            adj[u].append((w, v))
+            
+        while pq:
+            dis, node = heapq.heappop(pq)
+            if node in visited: continue
+            visited.add(node)
+            
+            ans = max(ans, dis)
+            
+            for d2, nei in adj[node]:
+                heapq.heappush(pq, (d2+dis, nei))
+        
+        return ans if len(visited)==N else -1
 
 
 
+"""
+Dijkstra Normal Implementation
+Time: O(N^2), N is the nodes count in the graph.
+"""
+class Solution(object):
+    def networkDelayTime(self, times, N, K):
+        #construct dis. dis[n] := node n distance to K
+        dis = {}
+        for n in xrange(1, N+1):
+            dis[n] = float('inf')
+        dis[K] = 0
+        
+        visited = set()
+        
+        #construct adjacency list
+        adj = collections.defaultdict(list)
+        for u, v, w in times:
+            adj[u].append((w, v))
+        
 
+        while len(visited)<N:
+            #find the nearest node to K, lets call it minDisNode
+            minDisNode = None
+            minDis = float('inf')
+            
+            for n in xrange(1, N+1):
+                if n not in visited and dis[n]<minDis:
+                    minDisNode = n
+                    minDis = dis[n]
+            
+            #update minDisNode neighbor's distance to K    
+            if minDis==float('inf'): break
+            for d2, nei in adj[minDisNode]:
+                dis[nei] = min(dis[nei], d2+minDis)
+            
+            #store the node we alreay determined the distance to K in visited
+            visited.add(minDisNode)
+        
+        return max(dis.values()) if len(visited)==N else -1
 
 
-
-
-
+"""
+Floyd
+Time: O(N^3), N is the nodes count in the graph.
+Note that Floyed can calculate the shortest distance between any two nodes.
+Also, it can handle negative values on the edge.
+"""
+class Solution(object):
+    def networkDelayTime(self, times, N, K):
+        #dp[i-1][j-1] := distance from i to j
+        dp = [[float('inf') for i in xrange(1, N+1)] for j in xrange(1, N+1)]
+        
+        for i in xrange(1, N+1):
+            dp[i-1][i-1] = 0
+        for u, v, w in times:
+            dp[u-1][v-1] = w
+        
+        for k in xrange(1, N+1):
+            for i in xrange(1, N+1):
+                for j in xrange(1, N+1):
+                    dp[i-1][j-1] = min(dp[i-1][j-1], dp[i-1][k-1]+dp[k-1][j-1])
+        
+        ans = max(dp[K-1])
+        return ans if ans!=float('inf') else -1
\ No newline at end of file
diff --git a/problems/next-closest-time.py b/problems/python/next-closest-time.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/next-closest-time.py
rename to problems/python/next-closest-time.py
diff --git a/problems/python/next-permutation.py b/problems/python/next-permutation.py
new file mode 100755
index 0000000..0a816ee
--- /dev/null
+++ b/problems/python/next-permutation.py
@@ -0,0 +1,61 @@
+"""
+This answer is the python version of the offical answer.
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def nextPermutation(self, nums):
+        def reverse(start):
+            end = len(nums)-1
+            
+            while start<end:
+                swap(start, end)
+                start += 1
+                end -= 1
+        
+        def swap(i, j):
+            nums[i], nums[j] = nums[j], nums[i]
+        
+        
+        i = len(nums)-2
+        
+        while i>=0 and nums[i+1]<=nums[i]:
+            i -= 1
+        
+        if i>=0:
+            j = len(nums)-1
+            while nums[j]<=nums[i]: j -= 1
+            swap(i, j)
+        
+        reverse(i+1)
+        return nums
+
+"""
+Next Permutation means find the next (slightly) larger number using nums.
+
+1. Iterate from right, find the first num that is smaller. That's the one we are going to swap. => nums[i]
+2. From the nums right to nums[i], find the smallest num that is larger than nums[i] => nums[j]
+Since the right of the i must be an increasing sequence (looking from right), the first one that larger than nums[i] is the smallest one that is larger than nums[i]
+3. Swap nums[i] and nums[j]
+4. sort nums[i+1:] it will be the smallest permutaion.
+5. Note that when an list is in increasing order looking from right, we can use `reverse` to sort it.
+"""
+class Solution(object):
+    def nextPermutation(self, nums):
+        def reverse(nums, l, r):
+            while l<=r:
+                nums[l], nums[r] = nums[r], nums[l]
+                l += 1
+                r -= 1
+            
+        i = len(nums)-2
+        while i>=0 and nums[i]>=nums[i+1]: i -= 1 #[1]
+        
+        if i==-1:
+            return reverse(nums, 0, len(nums)-1) #nums is the largest permutation, sort nums
+        else:
+            j = len(nums)-1
+            while j>i and nums[j]<=nums[i]: j -= 1 #[2]
+            nums[i], nums[j] = nums[j], nums[i] #[3]
+            reverse(nums, i+1, len(nums)-1) #[4]
\ No newline at end of file
diff --git a/problems/number-complement.py b/problems/python/number-complement.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-complement.py
rename to problems/python/number-complement.py
diff --git a/problems/number-of-connected-components-in-an-undirected-graph.py b/problems/python/number-of-connected-components-in-an-undirected-graph.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-connected-components-in-an-undirected-graph.py
rename to problems/python/number-of-connected-components-in-an-undirected-graph.py
diff --git a/problems/number-of-islands-ii.py b/problems/python/number-of-islands-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-islands-ii.py
rename to problems/python/number-of-islands-ii.py
diff --git a/problems/number-of-islands.py b/problems/python/number-of-islands.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-islands.py
rename to problems/python/number-of-islands.py
diff --git a/problems/number-of-longest-increasing-subsequence.py b/problems/python/number-of-longest-increasing-subsequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-longest-increasing-subsequence.py
rename to problems/python/number-of-longest-increasing-subsequence.py
diff --git a/problems/number-of-matching-subsequences.py b/problems/python/number-of-matching-subsequences.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-matching-subsequences.py
rename to problems/python/number-of-matching-subsequences.py
diff --git a/problems/number-of-provinces.py b/problems/python/number-of-provinces.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-provinces.py
rename to problems/python/number-of-provinces.py
diff --git a/problems/number-of-recent-calls.py b/problems/python/number-of-recent-calls.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-recent-calls.py
rename to problems/python/number-of-recent-calls.py
diff --git a/problems/number-of-squareful-arrays.py b/problems/python/number-of-squareful-arrays.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-squareful-arrays.py
rename to problems/python/number-of-squareful-arrays.py
diff --git a/problems/number-of-substrings-containing-all-thre.py b/problems/python/number-of-substrings-containing-all-thre.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/number-of-substrings-containing-all-thre.py
rename to problems/python/number-of-substrings-containing-all-thre.py
diff --git a/problems/python/number-of-ways-to-arrive-at-destination.py b/problems/python/number-of-ways-to-arrive-at-destination.py
new file mode 100755
index 0000000..3231254
--- /dev/null
+++ b/problems/python/number-of-ways-to-arrive-at-destination.py
@@ -0,0 +1,33 @@
+class Solution(object):
+    def countPaths(self, n, roads):
+        def countWaysToReach(node):
+            if node==0: return 1
+            if node in history: return history[node]
+            c = 0
+            for nei, t in adj[node]:
+                if nei in times and times[nei]+t==times[node]:
+                    c += countWaysToReach(nei)
+            history[node] = c
+            return c
+        
+        history = {} #cache for countWaysToReach()
+        times = {} #min times to reach node n-1
+        pq = [(0, 0)]
+        
+        adj = collections.defaultdict(list)
+        for u, v, t in roads:
+            adj[u].append((v, t))
+            adj[v].append((u, t))
+        
+        while pq:
+            t, node = heapq.heappop(pq)
+            if node in times: continue
+            times[node] = t
+            
+            if node==n-1: break
+            
+            for nei, t2 in adj[node]:
+                if nei in times: continue
+                heapq.heappush(pq, (t+t2, nei))
+        
+        return countWaysToReach(n-1)%(10**9 + 7)
\ No newline at end of file
diff --git a/problems/odd-even-jump.py b/problems/python/odd-even-jump.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/odd-even-jump.py
rename to problems/python/odd-even-jump.py
diff --git a/problems/ones-and-zeroes.py b/problems/python/ones-and-zeroes.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/ones-and-zeroes.py
rename to problems/python/ones-and-zeroes.py
diff --git a/problems/open-the-lock.py b/problems/python/open-the-lock.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/open-the-lock.py
rename to problems/python/open-the-lock.py
diff --git a/problems/out-of-boundary-paths.py b/problems/python/out-of-boundary-paths.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/out-of-boundary-paths.py
rename to problems/python/out-of-boundary-paths.py
diff --git a/problems/pacific-atlantic-water-flow.py b/problems/python/pacific-atlantic-water-flow.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/pacific-atlantic-water-flow.py
rename to problems/python/pacific-atlantic-water-flow.py
diff --git a/problems/pairs-of-songs-with-total-durations-divisible-by-60.py b/problems/python/pairs-of-songs-with-total-durations-divisible-by-60.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/pairs-of-songs-with-total-durations-divisible-by-60.py
rename to problems/python/pairs-of-songs-with-total-durations-divisible-by-60.py
diff --git a/problems/palindrome-number.py b/problems/python/palindrome-number.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/palindrome-number.py
rename to problems/python/palindrome-number.py
diff --git a/problems/palindrome-pairs.py b/problems/python/palindrome-pairs.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/palindrome-pairs.py
rename to problems/python/palindrome-pairs.py
diff --git a/problems/palindrome-partitioning-iii.py b/problems/python/palindrome-partitioning-iii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/palindrome-partitioning-iii.py
rename to problems/python/palindrome-partitioning-iii.py
diff --git a/problems/palindrome-partitioning.py b/problems/python/palindrome-partitioning.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/palindrome-partitioning.py
rename to problems/python/palindrome-partitioning.py
diff --git a/problems/palindromic-substrings.py b/problems/python/palindromic-substrings.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/palindromic-substrings.py
rename to problems/python/palindromic-substrings.py
diff --git a/problems/partition-array-for-maximum-sum.py b/problems/python/partition-array-for-maximum-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/partition-array-for-maximum-sum.py
rename to problems/python/partition-array-for-maximum-sum.py
diff --git a/problems/partition-labels.py b/problems/python/partition-labels.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/partition-labels.py
rename to problems/python/partition-labels.py
diff --git a/problems/partition-to-k-equal-sum-subsets.py b/problems/python/partition-to-k-equal-sum-subsets.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/partition-to-k-equal-sum-subsets.py
rename to problems/python/partition-to-k-equal-sum-subsets.py
diff --git a/problems/path-sum-ii.py b/problems/python/path-sum-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/path-sum-ii.py
rename to problems/python/path-sum-ii.py
diff --git a/problems/path-sum-iii.py b/problems/python/path-sum-iii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/path-sum-iii.py
rename to problems/python/path-sum-iii.py
diff --git a/problems/path-sum.py b/problems/python/path-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/path-sum.py
rename to problems/python/path-sum.py
diff --git a/problems/python/path-with-maximum-probability.py b/problems/python/path-with-maximum-probability.py
new file mode 100755
index 0000000..db1b1d4
--- /dev/null
+++ b/problems/python/path-with-maximum-probability.py
@@ -0,0 +1,24 @@
+class Solution(object):
+    def maxProbability(self, n, edges, succProb, start, end):
+        pq = [(-1, start)]
+        visited = set()
+        adj = collections.defaultdict(list)
+        for i in xrange(len(edges)):
+            a, b = edges[i]
+            p = succProb[i]
+            adj[a].append((b, p))
+            adj[b].append((a, p))
+        
+        while pq:
+            p, node = heapq.heappop(pq)
+            p = p*-1
+            if node in visited: continue
+            visited.add(node)
+            
+            if node==end: return p
+            
+            for nei, p2 in adj[node]:
+                if nei in visited: continue
+                heapq.heappush(pq, (-1*p*p2, nei))
+        
+        return 0
\ No newline at end of file
diff --git a/problems/peak-index-in-a-mountain-array.PY b/problems/python/peak-index-in-a-mountain-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/peak-index-in-a-mountain-array.PY
rename to problems/python/peak-index-in-a-mountain-array.py
diff --git a/problems/perfect-squares.py b/problems/python/perfect-squares.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/perfect-squares.py
rename to problems/python/perfect-squares.py
diff --git a/problems/permutation-in-string.py b/problems/python/permutation-in-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/permutation-in-string.py
rename to problems/python/permutation-in-string.py
diff --git a/problems/python/permutation-sequence.py b/problems/python/permutation-sequence.py
new file mode 100755
index 0000000..f7e5be2
--- /dev/null
+++ b/problems/python/permutation-sequence.py
@@ -0,0 +1,14 @@
+class Solution(object):
+    def getPermutation(self, N, K):
+        K = K-1 #make it 0-index
+        nums = range(1, N+1)
+        ans = ''
+        
+        while N>0:
+            a = K/math.factorial(N-1)
+            ans += str(nums[a])
+            nums.pop(a)
+            
+            K -= math.factorial(N-1)*(a+1)
+            N -= 1
+        return ans
\ No newline at end of file
diff --git a/problems/permutations-ii.py b/problems/python/permutations-ii.py
old mode 100644
new mode 100755
similarity index 71%
rename from problems/permutations-ii.py
rename to problems/python/permutations-ii.py
index e4aa3c2..a6c9ff7
--- a/problems/permutations-ii.py
+++ b/problems/python/permutations-ii.py
@@ -53,3 +53,28 @@ def helper(path):
         counter = collections.Counter(nums)
         helper([])
         return ans
+
+
+"""
+差板法
+"""
+class Solution(object):
+    def permuteUnique(self, nums):
+        if not nums: return []
+        
+        permutations = collections.deque([[nums[0]]])
+        
+        for i in xrange(1, len(nums)):
+            num = nums[i]
+            l = len(permutations)    
+            
+            while l:
+                permutation = permutations.popleft()
+                for j in xrange(len(permutation)+1):
+                    if 0<j and num==permutation[j-1]: break
+                    newPermutaion = permutation[:]
+                    newPermutaion.insert(j, num)
+                    permutations.append(newPermutaion)
+                l -= 1
+        
+        return permutations
\ No newline at end of file
diff --git a/problems/permutations.py b/problems/python/permutations.py
old mode 100644
new mode 100755
similarity index 79%
rename from problems/permutations.py
rename to problems/python/permutations.py
index bc27184..eb40d3a
--- a/problems/permutations.py
+++ b/problems/python/permutations.py
@@ -73,4 +73,28 @@ def helper(i):
         N = len(nums)
         ans = []
         helper(0)
-        return ans
\ No newline at end of file
+        return ans
+
+
+"""
+差板法
+"""
+class Solution(object):
+    def permute(self, nums):
+        if not nums: return []
+        
+        permutations = collections.deque([[nums[0]]])
+        
+        for i in xrange(1, len(nums)):
+            num = nums[i]
+            l = len(permutations)    
+            
+            while l:
+                permutation = permutations.popleft()
+                for j in xrange(len(permutation)+1):
+                    newPermutaion = permutation[:]
+                    newPermutaion.insert(j, num)
+                    permutations.append(newPermutaion)
+                l -= 1
+        
+        return permutations
\ No newline at end of file
diff --git a/problems/populating-next-right-pointers-in-each-node-ii.py b/problems/python/populating-next-right-pointers-in-each-node-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/populating-next-right-pointers-in-each-node-ii.py
rename to problems/python/populating-next-right-pointers-in-each-node-ii.py
diff --git a/problems/populating-next-right-pointers-in-each-node.py b/problems/python/populating-next-right-pointers-in-each-node.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/populating-next-right-pointers-in-each-node.py
rename to problems/python/populating-next-right-pointers-in-each-node.py
diff --git a/problems/python/powx-n.py b/problems/python/powx-n.py
new file mode 100755
index 0000000..d0fac2b
--- /dev/null
+++ b/problems/python/powx-n.py
@@ -0,0 +1,12 @@
+class Solution(object):
+    def myPow(self, x, n):
+        if n==0:
+            return 1
+        elif n<0:
+            return 1/self.myPow(x, -n)
+        elif n%2>0:
+            half = self.myPow(x, n-1)
+            return x*half
+        elif n%2==0:
+            half = self.myPow(x, n/2)
+            return half*half
\ No newline at end of file
diff --git a/problems/product-of-array-except-self.py b/problems/python/product-of-array-except-self.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/product-of-array-except-self.py
rename to problems/python/product-of-array-except-self.py
diff --git a/problems/python/profitable-schemes.py b/problems/python/profitable-schemes.py
new file mode 100755
index 0000000..2c16d85
--- /dev/null
+++ b/problems/python/profitable-schemes.py
@@ -0,0 +1,45 @@
+"""
+TLE
+dp[i][n][p] := considering profit[:i], what is the number of ways produce profit p with n people.
+"""
+class Solution(object):
+    def profitableSchemes(self, maxMember, minProfit, group, profit):
+        P = sum(profit)
+        N = sum(group)
+        dp = [[[0 for _ in xrange(P+1)] for _ in xrange(N+1)] for _ in xrange(len(profit)+1)]
+        dp[0][0][0] = 1
+        
+        count = 0
+        for i in xrange(1, len(profit)+1):
+            for n in xrange(N+1):
+                for p in xrange(P+1):
+                    dp[i][n][p] = (dp[i-1][n-group[i-1]][p-profit[i-1]] if p-profit[i-1]>=0 and n-group[i-1]>=0 else 0) + dp[i-1][n][p]
+                    if i==len(profit) and p>=minProfit and n<=maxMember: count += dp[i][n][p]
+        return count
+
+
+
+"""
+dp[i][g][p] := consider only crime[:i] the scheme that can generate profit p using man power g.
+"""
+class Solution(object):
+    def profitableSchemes(self, n, minProfit, group, profit):
+        N = len(profit)
+        
+        dp = [[[0]*(n+2) for _ in xrange(minProfit+1)] for _ in xrange(N+1)]
+        dp[0][0][0] = 1
+        
+        for i in xrange(1, N+1):
+            for p in xrange(minProfit+1):
+                for g in xrange(n+1):
+                    pi = profit[i-1]
+                    gi = group[i-1]
+                    
+                    #considerting last round using p and g
+                    dp[i][p][g] += dp[i-1][p][g]
+                    dp[i][min(pi+p, minProfit)][min(gi+g, n+1)] += dp[i-1][p][g]
+        
+        ans = 0
+        for g in xrange(n+1):
+            ans += dp[N][minProfit][g]
+        return ans % (10**9 + 7)
\ No newline at end of file
diff --git a/problems/queue-reconstruction-by-height.py b/problems/python/queue-reconstruction-by-height.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/queue-reconstruction-by-height.py
rename to problems/python/queue-reconstruction-by-height.py
diff --git a/problems/python/random-pick-with-weight.py b/problems/python/random-pick-with-weight.py
new file mode 100755
index 0000000..9c88bd0
--- /dev/null
+++ b/problems/python/random-pick-with-weight.py
@@ -0,0 +1,29 @@
+"""
+For W = [1,3,2,4] (total 10, 1+2+3+4)
+Think of a line _,___,__,____ ([1,4,6,10])
+Now we randomly throw a ball on the line the probability to land on the first section will be 1/10.
+the second section, 3/10.
+the third section, 2/10.
+the forth section, 4/10.
+
+Above is equivilant to we randomly pick a number [0~10) and see which section it is in.
+And since the cumulative probability in the "line" is strictly increasing, we can use binary search.
+
+Time: O(LogN), N is the number of W.
+Space: O(N).
+"""
+from random import randrange
+
+class Solution(object):
+
+    def __init__(self, W):
+        self.line = [] #cumulative probability distribution
+        self.total = 0
+        
+        for w in W:
+            self.total += w
+            self.line.append(self.total)
+
+    def pickIndex(self):
+        rand = random.randrange(self.total)
+        return bisect.bisect(self.line, rand)
\ No newline at end of file
diff --git a/problems/range-addition.py b/problems/python/range-addition.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/range-addition.py
rename to problems/python/range-addition.py
diff --git a/problems/python/range-sum-of-bst.py b/problems/python/range-sum-of-bst.py
new file mode 100755
index 0000000..0ca07ed
--- /dev/null
+++ b/problems/python/range-sum-of-bst.py
@@ -0,0 +1,11 @@
+class Solution(object):
+    def rangeSumBST(self, root, low, high):
+        def helper(node, low, high):
+            total = 0
+            if not node: return total
+            if low<=node.val<=high: total += node.val
+            if node.val<=high: total += helper(node.right, low, high)
+            if node.val>=low: total += helper(node.left, low, high)
+            return total
+        
+        return helper(root, low, high)
\ No newline at end of file
diff --git a/problems/range-sum-query-immutable.py b/problems/python/range-sum-query-immutable.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/range-sum-query-immutable.py
rename to problems/python/range-sum-query-immutable.py
diff --git a/problems/range-sum-query-mutable.py b/problems/python/range-sum-query-mutable.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/range-sum-query-mutable.py
rename to problems/python/range-sum-query-mutable.py
diff --git a/problems/rearrange-string-k-distance-apart.py b/problems/python/rearrange-string-k-distance-apart.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/rearrange-string-k-distance-apart.py
rename to problems/python/rearrange-string-k-distance-apart.py
diff --git a/problems/reconstruct-itinerary.py b/problems/python/reconstruct-itinerary.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/reconstruct-itinerary.py
rename to problems/python/reconstruct-itinerary.py
diff --git a/problems/recover-binary-search-tree.py b/problems/python/recover-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/recover-binary-search-tree.py
rename to problems/python/recover-binary-search-tree.py
diff --git a/problems/redundant-connection.py b/problems/python/redundant-connection.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/redundant-connection.py
rename to problems/python/redundant-connection.py
diff --git a/problems/python/remove-all-adjacent-duplicates-in-string.py b/problems/python/remove-all-adjacent-duplicates-in-string.py
new file mode 100755
index 0000000..f4bb906
--- /dev/null
+++ b/problems/python/remove-all-adjacent-duplicates-in-string.py
@@ -0,0 +1,12 @@
+class Solution(object):
+    def removeDuplicates(self, s):
+        stack = []
+        i = 0
+        while i<len(s):
+            if stack and stack[-1]==s[i]:
+                stack.pop()    
+            else:
+                stack.append(s[i])
+            i += 1
+        
+        return ''.join(stack)
\ No newline at end of file
diff --git a/problems/remove-all-ones-with-row-and-column-flips.py b/problems/python/remove-all-ones-with-row-and-column-flips.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/remove-all-ones-with-row-and-column-flips.py
rename to problems/python/remove-all-ones-with-row-and-column-flips.py
diff --git a/problems/remove-duplicates-from-sorted-array-ii.py b/problems/python/remove-duplicates-from-sorted-array-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/remove-duplicates-from-sorted-array-ii.py
rename to problems/python/remove-duplicates-from-sorted-array-ii.py
diff --git a/problems/remove-duplicates-from-sorted-array.py b/problems/python/remove-duplicates-from-sorted-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/remove-duplicates-from-sorted-array.py
rename to problems/python/remove-duplicates-from-sorted-array.py
diff --git a/problems/remove-duplicates-from-sorted-list.py b/problems/python/remove-duplicates-from-sorted-list.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/remove-duplicates-from-sorted-list.py
rename to problems/python/remove-duplicates-from-sorted-list.py
diff --git a/problems/remove-element.py b/problems/python/remove-element.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/remove-element.py
rename to problems/python/remove-element.py
diff --git a/problems/python/remove-invalid-parentheses.py b/problems/python/remove-invalid-parentheses.py
new file mode 100755
index 0000000..0cb7695
--- /dev/null
+++ b/problems/python/remove-invalid-parentheses.py
@@ -0,0 +1,38 @@
+class Solution(object):
+    def removeInvalidParentheses(self, s):
+        def dfs(s, curr, i, count):
+            if count<0: return
+            if len(curr)>self.maxLen: return
+            
+            if i>=len(s):
+                if len(curr)==self.maxLen and count==0:
+                    self.ans.append(curr)
+                return
+            
+            if s[i]!='(' and s[i]!=')':
+                dfs(s, curr+s[i], i+1, count)
+            elif not curr or s[i]!=curr[-1]:
+                dfs(s, curr+s[i], i+1, count + (1 if s[i]=='(' else -1))
+                dfs(s, curr, i+1, count)
+            elif s[i]==curr[-1]:
+                dfs(s, curr+s[i], i+1, count + (1 if s[i]=='(' else -1))
+                
+        def getMaxLen(s):
+            openCount = removeCount = 0
+            for c in s:
+                if c=='(':
+                    openCount += 1
+                elif c==')':
+                    openCount -= 1
+                
+                if openCount<0:
+                    removeCount += abs(openCount)
+                    openCount = 0
+            removeCount += openCount   
+            return len(s)-removeCount
+        
+        self.ans = []
+        self.maxLen = getMaxLen(s)
+        
+        dfs(s, "", 0, 0)
+        return self.ans
\ No newline at end of file
diff --git a/problems/remove-linked-list-elements.py b/problems/python/remove-linked-list-elements.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/remove-linked-list-elements.py
rename to problems/python/remove-linked-list-elements.py
diff --git a/problems/remove-nth-node-from-end-of-list.py b/problems/python/remove-nth-node-from-end-of-list.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/remove-nth-node-from-end-of-list.py
rename to problems/python/remove-nth-node-from-end-of-list.py
diff --git a/problems/reorder-list.py b/problems/python/reorder-list.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/reorder-list.py
rename to problems/python/reorder-list.py
diff --git a/problems/repeated-string-match.py b/problems/python/repeated-string-match.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/repeated-string-match.py
rename to problems/python/repeated-string-match.py
diff --git a/problems/replace-the-substring-for-balanced-string.py b/problems/python/replace-the-substring-for-balanced-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/replace-the-substring-for-balanced-string.py
rename to problems/python/replace-the-substring-for-balanced-string.py
diff --git a/problems/restore-ip-addresses.py b/problems/python/restore-ip-addresses.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/restore-ip-addresses.py
rename to problems/python/restore-ip-addresses.py
diff --git a/problems/reverse-integer.py b/problems/python/reverse-integer.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/reverse-integer.py
rename to problems/python/reverse-integer.py
diff --git a/problems/reverse-linked-list.py b/problems/python/reverse-linked-list.py
old mode 100644
new mode 100755
similarity index 73%
rename from problems/reverse-linked-list.py
rename to problems/python/reverse-linked-list.py
index 46eedea..9b60a26
--- a/problems/reverse-linked-list.py
+++ b/problems/python/reverse-linked-list.py
@@ -43,3 +43,19 @@ def reverseList(self, node):
             if not next_node: return node
             pre = node
             node = next_node
+
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution(object):
+    def reverseList(self, head):
+        if not head or not head.next: return head
+        
+        reversedHead = self.reverseList(head.next)
+        head.next.next = head
+        head.next = None
+        return reversedHead
+        
\ No newline at end of file
diff --git a/problems/reverse-string.py b/problems/python/reverse-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/reverse-string.py
rename to problems/python/reverse-string.py
diff --git a/problems/reverse-vowels-of-a-string.py b/problems/python/reverse-vowels-of-a-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/reverse-vowels-of-a-string.py
rename to problems/python/reverse-vowels-of-a-string.py
diff --git a/problems/reverse-words-in-a-string.py b/problems/python/reverse-words-in-a-string.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/reverse-words-in-a-string.py
rename to problems/python/reverse-words-in-a-string.py
diff --git a/problems/robot-bounded-in-circle.py b/problems/python/robot-bounded-in-circle.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/robot-bounded-in-circle.py
rename to problems/python/robot-bounded-in-circle.py
diff --git a/problems/roman-to-integer.py b/problems/python/roman-to-integer.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/roman-to-integer.py
rename to problems/python/roman-to-integer.py
diff --git a/problems/rotate-array.py b/problems/python/rotate-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/rotate-array.py
rename to problems/python/rotate-array.py
diff --git a/problems/rotate-image.py b/problems/python/rotate-image.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/rotate-image.py
rename to problems/python/rotate-image.py
diff --git a/problems/russian-doll-envelopes.py b/problems/python/russian-doll-envelopes.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/russian-doll-envelopes.py
rename to problems/python/russian-doll-envelopes.py
diff --git a/problems/same-tree.py b/problems/python/same-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/same-tree.py
rename to problems/python/same-tree.py
diff --git a/problems/satisfiability-of-equality-equations.py b/problems/python/satisfiability-of-equality-equations.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/satisfiability-of-equality-equations.py
rename to problems/python/satisfiability-of-equality-equations.py
diff --git a/problems/score-of-parentheses.py b/problems/python/score-of-parentheses.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/score-of-parentheses.py
rename to problems/python/score-of-parentheses.py
diff --git a/problems/search-a-2d-matrix.py b/problems/python/search-a-2d-matrix.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/search-a-2d-matrix.py
rename to problems/python/search-a-2d-matrix.py
diff --git a/problems/search-in-a-binary-search-tree.py b/problems/python/search-in-a-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/search-in-a-binary-search-tree.py
rename to problems/python/search-in-a-binary-search-tree.py
diff --git a/problems/search-in-rotated-sorted-array-ii.py b/problems/python/search-in-rotated-sorted-array-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/search-in-rotated-sorted-array-ii.py
rename to problems/python/search-in-rotated-sorted-array-ii.py
diff --git a/problems/search-in-rotated-sorted-array.py b/problems/python/search-in-rotated-sorted-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/search-in-rotated-sorted-array.py
rename to problems/python/search-in-rotated-sorted-array.py
diff --git a/problems/search-insert-position.py b/problems/python/search-insert-position.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/search-insert-position.py
rename to problems/python/search-insert-position.py
diff --git a/problems/search-suggestions-system.py b/problems/python/search-suggestions-system.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/search-suggestions-system.py
rename to problems/python/search-suggestions-system.py
diff --git a/problems/second-highest-salary.sql b/problems/python/second-highest-salary.sql
old mode 100644
new mode 100755
similarity index 100%
rename from problems/second-highest-salary.sql
rename to problems/python/second-highest-salary.sql
diff --git a/problems/sell-diminishing-valued-colored-balls.py b/problems/python/sell-diminishing-valued-colored-balls.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/sell-diminishing-valued-colored-balls.py
rename to problems/python/sell-diminishing-valued-colored-balls.py
diff --git a/problems/serialize-and-deserialize-binary-tree.py b/problems/python/serialize-and-deserialize-binary-tree.py
old mode 100644
new mode 100755
similarity index 64%
rename from problems/serialize-and-deserialize-binary-tree.py
rename to problems/python/serialize-and-deserialize-binary-tree.py
index 9519b74..e48f9d2
--- a/problems/serialize-and-deserialize-binary-tree.py
+++ b/problems/python/serialize-and-deserialize-binary-tree.py
@@ -39,4 +39,25 @@ def deserialize(self, data):
                 q.append(node.right)
             i += 1
             
-        return root
\ No newline at end of file
+        return root
+
+
+
+#Preorder traversal
+class Codec:
+    def serialize(self, root):
+        if not root: return '#,'
+        return str(root.val) + ',' + self.serialize(root.left) + self.serialize(root.right)
+    
+    def deserialize(self, data):
+        data = data.split(',')[::-1]
+        return self.getNode(data)
+    
+    def getNode(self, data):
+        if not data: return None
+        val = data.pop()
+        if val=='#': return None
+        node = TreeNode(val)
+        node.left = self.getNode(data)
+        node.right = self.getNode(data)
+        return node
\ No newline at end of file
diff --git a/problems/serialize-and-deserialize-bst.py b/problems/python/serialize-and-deserialize-bst.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/serialize-and-deserialize-bst.py
rename to problems/python/serialize-and-deserialize-bst.py
diff --git a/problems/set-matrix-zeroes.py b/problems/python/set-matrix-zeroes.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/set-matrix-zeroes.py
rename to problems/python/set-matrix-zeroes.py
diff --git a/problems/shortest-bridge.py b/problems/python/shortest-bridge.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/shortest-bridge.py
rename to problems/python/shortest-bridge.py
diff --git a/problems/shortest-common-supersequence.py b/problems/python/shortest-common-supersequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/shortest-common-supersequence.py
rename to problems/python/shortest-common-supersequence.py
diff --git a/problems/python/shortest-distance-from-all-buildings.py b/problems/python/shortest-distance-from-all-buildings.py
new file mode 100755
index 0000000..490e6a2
--- /dev/null
+++ b/problems/python/shortest-distance-from-all-buildings.py
@@ -0,0 +1,39 @@
+class Solution(object):
+    def shortestDistance(self, grid):
+        def bfs(i0, j0):
+            q = collections.deque([(i0, j0, 0)])
+            visited = set()
+            while q:
+                i, j, dis = q.popleft()
+                if (i, j) in visited: continue
+                visited.add((i, j))
+                
+                reach[i][j] += 1
+                distances[i][j] += dis
+                
+                for iNext, jNext in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):
+                    if not (0<=iNext<len(grid) and 0<=jNext<len(grid[0])): continue
+                    if grid[iNext][jNext]==2 or grid[iNext][jNext]==1: continue
+                    if (iNext, jNext) in visited: continue
+                    q.append((iNext, jNext, dis+1))
+        
+        M = len(grid)
+        N = len(grid[0])
+        ans = float('inf')
+        reach = [[0]*N for _ in xrange(M)] #number of buildings can reach (i, j)
+        distances = [[0]*N for _ in xrange(M)] #aggregate distance btwn 0 and buildings.
+        buildingCount = 0
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]==1:
+                    buildingCount += 1
+                    bfs(i, j)
+        
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                if grid[i][j]==0 and reach[i][j]==buildingCount:
+                    ans = min(ans, distances[i][j])
+        
+        return ans if ans!=float('inf') else -1
\ No newline at end of file
diff --git a/problems/shortest-path-in-a-grid-with-obstacles-elimination.py b/problems/python/shortest-path-in-a-grid-with-obstacles-elimination.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/shortest-path-in-a-grid-with-obstacles-elimination.py
rename to problems/python/shortest-path-in-a-grid-with-obstacles-elimination.py
diff --git a/problems/python/shortest-path-in-binary-matrix.py b/problems/python/shortest-path-in-binary-matrix.py
new file mode 100755
index 0000000..6811948
--- /dev/null
+++ b/problems/python/shortest-path-in-binary-matrix.py
@@ -0,0 +1,17 @@
+class Solution(object):
+    def shortestPathBinaryMatrix(self, grid):
+        q = collections.deque([(0, 0, 1)])
+        seen = 2
+        
+        while q:
+            i, j, step = q.popleft()
+            if not (0<=i<len(grid) and 0<=j<len(grid[0])): continue
+            if grid[i][j]==1 or grid[i][j]==seen: continue
+            grid[i][j] = seen
+            
+            if i==len(grid)-1 and j==len(grid[0])-1: return step
+            
+            for k, l in ((i+1, j), (i-1, j), (i, j+1), (i, j-1), (i-1, j-1), (i+1, j-1), (i+1, j+1), (i-1, j+1)):
+                q.append((k, l, step+1))
+        
+        return -1
\ No newline at end of file
diff --git a/problems/shortest-path-to-get-food.py b/problems/python/shortest-path-to-get-food.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/shortest-path-to-get-food.py
rename to problems/python/shortest-path-to-get-food.py
diff --git a/problems/shuffle-an-array.py b/problems/python/shuffle-an-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/shuffle-an-array.py
rename to problems/python/shuffle-an-array.py
diff --git a/problems/python/simplify-path.py b/problems/python/simplify-path.py
new file mode 100755
index 0000000..46589cf
--- /dev/null
+++ b/problems/python/simplify-path.py
@@ -0,0 +1,18 @@
+class Solution(object):
+    def simplifyPath(self, path):
+        ans = ''
+        skip = 0
+        
+        for directory in reversed(path.split('/')):
+            if directory=='' or directory=='.':
+                continue
+            elif directory=='..':
+                skip += 1
+            else:
+                if skip>0:
+                    skip -= 1
+                    continue
+                else:
+                    ans = '/'+directory+ans
+        
+        return ans if ans!='' else '/'
\ No newline at end of file
diff --git a/problems/python/single-threaded-cpu.py b/problems/python/single-threaded-cpu.py
new file mode 100755
index 0000000..fe30e21
--- /dev/null
+++ b/problems/python/single-threaded-cpu.py
@@ -0,0 +1,22 @@
+class Solution(object):
+    def getOrder(self, tasks):
+        ans = []
+        tasks = sorted([(task[0], task[1], i) for i, task in enumerate(tasks)], reverse=True)
+        pq = [] #tasks available
+        now = 0
+        
+        
+        while tasks or pq:
+            #check if the task is availiable, if yes, add to pq
+            while tasks and tasks[-1][0]<=now:
+                startTime, processTime, i = tasks.pop()
+                heapq.heappush(pq, (processTime, i))
+                        
+            if pq:
+                processTime, i = heapq.heappop(pq)
+                ans.append(i)
+                now += processTime
+            else:
+                now = tasks[-1][0]
+                    
+        return ans
\ No newline at end of file
diff --git a/problems/sliding-window-maximum.py b/problems/python/sliding-window-maximum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/sliding-window-maximum.py
rename to problems/python/sliding-window-maximum.py
diff --git a/problems/snapshot-array.py b/problems/python/snapshot-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/snapshot-array.py
rename to problems/python/snapshot-array.py
diff --git a/problems/sort-colors.py b/problems/python/sort-colors.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/sort-colors.py
rename to problems/python/sort-colors.py
diff --git a/problems/sort-list.py b/problems/python/sort-list.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/sort-list.py
rename to problems/python/sort-list.py
diff --git a/problems/spiral-matrix.py b/problems/python/spiral-matrix.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/spiral-matrix.py
rename to problems/python/spiral-matrix.py
diff --git a/problems/split-array-into-fibonacci-sequence.py b/problems/python/split-array-into-fibonacci-sequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/split-array-into-fibonacci-sequence.py
rename to problems/python/split-array-into-fibonacci-sequence.py
diff --git a/problems/split-array-largest-sum.py b/problems/python/split-array-largest-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/split-array-largest-sum.py
rename to problems/python/split-array-largest-sum.py
diff --git a/problems/sqrtx.py b/problems/python/sqrtx.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/sqrtx.py
rename to problems/python/sqrtx.py
diff --git a/problems/squares-of-a-sorted-array.py b/problems/python/squares-of-a-sorted-array.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/squares-of-a-sorted-array.py
rename to problems/python/squares-of-a-sorted-array.py
diff --git a/problems/python/step-by-step-directions-from-a-binary-tree-node-to-another.py b/problems/python/step-by-step-directions-from-a-binary-tree-node-to-another.py
new file mode 100755
index 0000000..a9177d4
--- /dev/null
+++ b/problems/python/step-by-step-directions-from-a-binary-tree-node-to-another.py
@@ -0,0 +1,36 @@
+class Solution(object):
+    def __init__(self):
+        self.lca = None
+        
+    def getDirections(self, root, startValue, destValue):
+        def findPath(node, path, val):
+            if not node: return False
+            if node.val==val: return True
+            
+            path.append('L')
+            if findPath(node.left, path, val): return True
+            path.pop()
+            
+            path.append('R')
+            if findPath(node.right, path, val): return True
+            path.pop()
+            
+            return False
+            
+        def findCount(node, startValue, destValue):
+            if not node: return 0
+            count = 0
+            if node.val==startValue or node.val==destValue: count += 1
+            count += findCount(node.left, startValue, destValue)
+            count += findCount(node.right, startValue, destValue)
+            if count>=2 and not self.lca: self.lca = node
+            return count
+        
+        findCount(root, startValue, destValue)
+        
+        path1 = []
+        findPath(self.lca, path1, startValue)
+        path2 = []
+        findPath(self.lca, path2, destValue)
+        
+        return 'U'*len(path1) + ''.join(path2)
\ No newline at end of file
diff --git a/problems/stock-price-fluctuation.py b/problems/python/stock-price-fluctuation.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/stock-price-fluctuation.py
rename to problems/python/stock-price-fluctuation.py
diff --git a/problems/stone-game-ii.py b/problems/python/stone-game-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/stone-game-ii.py
rename to problems/python/stone-game-ii.py
diff --git a/problems/student-attendance-record-ii.py b/problems/python/student-attendance-record-ii.py
old mode 100644
new mode 100755
similarity index 98%
rename from problems/student-attendance-record-ii.py
rename to problems/python/student-attendance-record-ii.py
index ed55473..efc2923
--- a/problems/student-attendance-record-ii.py
+++ b/problems/python/student-attendance-record-ii.py
@@ -17,7 +17,6 @@ def checkRecord(self, n):
             dp[i] += dp[i-1]%M #ends at P
             dp[i] += (dp[i-1]%M - dp[i-4]%M) #ends at L. All posiblity but the end cannot be PLL
         
-        
         ans += dp[n]
         
         for i in xrange(n):
diff --git a/problems/subarray-sum-equals-k.py b/problems/python/subarray-sum-equals-k.py
old mode 100644
new mode 100755
similarity index 97%
rename from problems/subarray-sum-equals-k.py
rename to problems/python/subarray-sum-equals-k.py
index 3220cff..0158b04
--- a/problems/subarray-sum-equals-k.py
+++ b/problems/python/subarray-sum-equals-k.py
@@ -39,7 +39,6 @@ def subarraySum(self, nums, k):
 """
 class Solution(object):
     def subarraySum(self, nums, k):
-        N = len(nums)
         ans = 0
         
         prefixSumCount = collections.Counter()
@@ -52,4 +51,4 @@ def subarraySum(self, nums, k):
             ans += prefixSumCount[I] #there are "prefixSumCount[I]" combinations of J-I that equals to k.
             prefixSumCount[J] += 1
             
-        return ans
\ No newline at end of file
+        return ans
diff --git a/problems/subarrays-with-k-different-integers.py b/problems/python/subarrays-with-k-different-integers.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/subarrays-with-k-different-integers.py
rename to problems/python/subarrays-with-k-different-integers.py
diff --git a/problems/subdomain-visit-count.py b/problems/python/subdomain-visit-count.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/subdomain-visit-count.py
rename to problems/python/subdomain-visit-count.py
diff --git a/problems/subsets-ii.py b/problems/python/subsets-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/subsets-ii.py
rename to problems/python/subsets-ii.py
diff --git a/problems/subsets.py b/problems/python/subsets.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/subsets.py
rename to problems/python/subsets.py
diff --git a/problems/substring-with-concatenation-of-all-words.py b/problems/python/substring-with-concatenation-of-all-words.py
old mode 100644
new mode 100755
similarity index 99%
rename from problems/substring-with-concatenation-of-all-words.py
rename to problems/python/substring-with-concatenation-of-all-words.py
index b11bb81..e3e6420
--- a/problems/substring-with-concatenation-of-all-words.py
+++ b/problems/python/substring-with-concatenation-of-all-words.py
@@ -47,4 +47,6 @@ def test(self, s, wl, countExpected):
             
         return True
         
-        
\ No newline at end of file
+
+
+
diff --git a/problems/subtree-of-another-tree.py b/problems/python/subtree-of-another-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/subtree-of-another-tree.py
rename to problems/python/subtree-of-another-tree.py
diff --git a/problems/sum-of-subarray-minimums.py b/problems/python/sum-of-subarray-minimums.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/sum-of-subarray-minimums.py
rename to problems/python/sum-of-subarray-minimums.py
diff --git a/problems/sum-root-to-leaf-numbers.py b/problems/python/sum-root-to-leaf-numbers.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/sum-root-to-leaf-numbers.py
rename to problems/python/sum-root-to-leaf-numbers.py
diff --git a/problems/summary-ranges.py b/problems/python/summary-ranges.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/summary-ranges.py
rename to problems/python/summary-ranges.py
diff --git a/problems/super-ugly-number.py b/problems/python/super-ugly-number.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/super-ugly-number.py
rename to problems/python/super-ugly-number.py
diff --git a/problems/python/swap-adjacent-in-lr-string.py b/problems/python/swap-adjacent-in-lr-string.py
new file mode 100755
index 0000000..a8acf65
--- /dev/null
+++ b/problems/python/swap-adjacent-in-lr-string.py
@@ -0,0 +1,18 @@
+class Solution(object):
+    def canTransform(self, start, end):
+        if len(start)!=len(end): return False
+        if start.replace('X', '')!=end.replace('X', ''): return False
+        
+        startLIndex = [i for i, c in enumerate(start) if c=='L']
+        endLIndex = [i for i, c in enumerate(end) if c=='L']
+        for i in xrange(len(startLIndex)):
+            if startLIndex[i]<endLIndex[i]:
+                return False
+        
+        startRIndex = [i for i, c in enumerate(start) if c=='R']
+        endRIndex = [i for i, c in enumerate(end) if c=='R']
+        for i in xrange(len(startRIndex)):
+            if startRIndex[i]>endRIndex[i]:
+                return False
+        
+        return True
\ No newline at end of file
diff --git a/problems/swap-nodes-in-pairs.py b/problems/python/swap-nodes-in-pairs.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/swap-nodes-in-pairs.py
rename to problems/python/swap-nodes-in-pairs.py
diff --git a/problems/swim-in-rising-water.py b/problems/python/swim-in-rising-water.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/swim-in-rising-water.py
rename to problems/python/swim-in-rising-water.py
diff --git a/problems/symmetric-tree.py b/problems/python/symmetric-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/symmetric-tree.py
rename to problems/python/symmetric-tree.py
diff --git a/problems/tallest-billboard.py b/problems/python/tallest-billboard.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/tallest-billboard.py
rename to problems/python/tallest-billboard.py
diff --git a/problems/target-sum.py b/problems/python/target-sum.py
old mode 100644
new mode 100755
similarity index 72%
rename from problems/target-sum.py
rename to problems/python/target-sum.py
index 75d9abe..c216522
--- a/problems/target-sum.py
+++ b/problems/python/target-sum.py
@@ -55,4 +55,23 @@ def findTargetSumWays(self, nums, target):
             for t in xrange(minTarget, maxTarget+1):
                 dp[i][t] = (dp[i-1][t-nums[i-1]] if t-nums[i-1]>=minTarget else 0) + (dp[i-1][t+nums[i-1]] if t+nums[i-1]<=maxTarget else 0)
         
-        return dp[N][target]
\ No newline at end of file
+        return dp[N][target]
+
+
+"""
+dp[i][s] := considerting nums[:i] how many expressions can sum up to s.
+dp[0][0] = 1
+"""
+class Solution(object):
+    def findTargetSumWays(self, nums, target):
+        S = sum(nums)
+        if not -S<=target<=S: return 0
+        
+        dp = [{s:0 for s in xrange(-S, S+1)} for _ in xrange(len(nums)+1)]
+        dp[0][0] = 1
+        
+        for i in xrange(1, len(nums)+1):
+            for s in xrange(-S, S+1):
+                dp[i][s] = (dp[i-1][s+nums[i-1]] if s+nums[i-1]<=S else 0) + (dp[i-1][s-nums[i-1]] if s-nums[i-1]>=-S else 0)
+        
+        return dp[-1][target]
\ No newline at end of file
diff --git a/problems/task-scheduler.py b/problems/python/task-scheduler.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/task-scheduler.py
rename to problems/python/task-scheduler.py
diff --git a/problems/text-justification.py b/problems/python/text-justification.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/text-justification.py
rename to problems/python/text-justification.py
diff --git a/problems/the-kth-factor-of-n.py b/problems/python/the-kth-factor-of-n.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/the-kth-factor-of-n.py
rename to problems/python/the-kth-factor-of-n.py
diff --git a/problems/python/the-maze-ii.py b/problems/python/the-maze-ii.py
new file mode 100755
index 0000000..6ab19bc
--- /dev/null
+++ b/problems/python/the-maze-ii.py
@@ -0,0 +1,45 @@
+class Solution(object):
+    def shortestDistance(self, maze, start, destination):
+        N, M = len(maze), len(maze[0])
+        i0, j0 = start
+        pq = [(0, i0, j0, 'stop')]
+        visited = set()
+        
+        
+        while pq:
+            dis, i, j, direction = heapq.heappop(pq)
+            if (i, j, direction) in visited: continue
+            visited.add((i, j, direction))
+            
+            if i<0 or i>=N or j<0 or j>=M: continue
+            if maze[i][j]==1: continue
+            
+            if i==destination[0] and j==destination[1] and direction=='stop': return dis
+                
+            if direction=='stop':
+                heapq.heappush(pq, (dis+1, i-1, j, 'left'))
+                heapq.heappush(pq, (dis+1, i+1, j, 'right'))
+                heapq.heappush(pq, (dis+1, i, j-1, 'down'))
+                heapq.heappush(pq, (dis+1, i, j+1, 'up'))
+            elif direction=='left':
+                if i-1<0 or i-1>=N or j<0 or j>=M or maze[i-1][j]==1:
+                    heapq.heappush(pq, (dis, i, j, 'stop'))
+                else:
+                    heapq.heappush(pq, (dis+1, i-1, j, direction))
+            elif direction=='right':
+                if i+1<0 or i+1>=N or j<0 or j>=M or maze[i+1][j]==1:
+                    heapq.heappush(pq, (dis, i, j, 'stop'))
+                else:
+                    heapq.heappush(pq, (dis+1, i+1, j, direction))
+            elif direction=='down':
+                if i<0 or i>=N or j-1<0 or j-1>=M or maze[i][j-1]==1:
+                    heapq.heappush(pq, (dis, i, j, 'stop'))
+                else:
+                    heapq.heappush(pq, (dis+1, i, j-1, direction))
+            elif direction=='up':
+                if i<0 or i>=N or j+1<0 or j+1>=M or maze[i][j+1]==1:
+                    heapq.heappush(pq, (dis, i, j, 'stop'))
+                else:
+                    heapq.heappush(pq, (dis+1, i, j+1, direction))
+                    
+        return -1
\ No newline at end of file
diff --git a/problems/time-based-key-value-store.py b/problems/python/time-based-key-value-store.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/time-based-key-value-store.py
rename to problems/python/time-based-key-value-store.py
diff --git a/problems/to-lower-case.py b/problems/python/to-lower-case.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/to-lower-case.py
rename to problems/python/to-lower-case.py
diff --git a/problems/python/toeplitz-matrix.py b/problems/python/toeplitz-matrix.py
new file mode 100755
index 0000000..431ce27
--- /dev/null
+++ b/problems/python/toeplitz-matrix.py
@@ -0,0 +1,22 @@
+class Solution(object):
+    def isToeplitzMatrix(self, matrix):
+        def check(i0, j0, matrix):
+            i = i0
+            j = j0
+            
+            while 0<=i<len(matrix) and 0<=j<len(matrix[0]):
+                if matrix[i][j]!=matrix[i0][j0]: return False
+                i += 1
+                j += 1
+            return True
+    
+        M = len(matrix)
+        N = len(matrix[0])
+        
+        for i in xrange(M-1, 0, -1):
+            if not check(i, 0, matrix): return False
+        
+        for j in xrange(N):
+            if not check(0, j, matrix): return False
+        
+        return True
\ No newline at end of file
diff --git a/problems/top-k-frequent-elements.py b/problems/python/top-k-frequent-elements.py
old mode 100644
new mode 100755
similarity index 66%
rename from problems/top-k-frequent-elements.py
rename to problems/python/top-k-frequent-elements.py
index fbb68a6..e1dea8c
--- a/problems/top-k-frequent-elements.py
+++ b/problems/python/top-k-frequent-elements.py
@@ -88,4 +88,62 @@ def topKFrequent(self, nums, k):
             ans.append(num)
             k -= 1
         
+        return ans
+
+"""
+Bucket sort for counts.
+Space/Time: O(N)
+"""
+class Solution(object):
+    def topKFrequent(self, nums, k):
+        counter = collections.Counter(nums)
+        count2Nums = [[] for _ in xrange(len(nums)+1)] #count2Nums[i] := elements with count i
+        
+        for num in counter:
+            count2Nums[counter[num]].append(num)
+        
+        ans = []
+        for i in xrange(len(count2Nums)-1, -1, -1):
+            ans += count2Nums[i]
+            if len(ans)>=k: break
+        
+        return ans
+
+
+# Quick Select
+class Solution(object):
+    def topKFrequent(self, nums, K):
+        def quickselect(A, s, e, K):
+            i = s
+            t = s
+            j = e
+            
+            pivot = A[(s+e)/2][0]
+            while t<=j:
+                if A[t][0]<pivot:
+                    A[t], A[i] = A[i], A[t]
+                    i += 1
+                    t += 1
+                elif A[t][0]==pivot:
+                    t += 1
+                else:
+                    A[t], A[j] = A[j], A[t]
+                    j -=1
+            
+            if e-j>=K:
+                return quickselect(A, j+1, e, K)
+            elif e-(i-1)>=K:
+                return pivot
+            else:
+                return quickselect(A, s, i-1, K-(e-i+1))
+                
+        ans = []
+        counter = collections.Counter(nums)
+        freqs = [(counter[num], num) for num in counter]
+        
+        KthLargestFreq = quickselect(freqs, 0, len(freqs)-1, K)
+        
+        for freq, num in freqs:
+            if freq>=KthLargestFreq: ans.append(num)
+                
         return ans
\ No newline at end of file
diff --git a/problems/python/trapping-rain-water-ii.py b/problems/python/trapping-rain-water-ii.py
new file mode 100755
index 0000000..dd14bc7
--- /dev/null
+++ b/problems/python/trapping-rain-water-ii.py
@@ -0,0 +1,28 @@
+class Solution(object):
+    def trapRainWater(self, heightMap):
+        pq = []
+        N = len(heightMap)
+        M = len(heightMap[0])
+        visited = set()
+        ans = 0
+        curr = float('-inf')
+        
+        for i in xrange(N):
+            for j in xrange(M):
+                if i==0 or i==N-1 or j==0 or j==M-1:
+                    heapq.heappush(pq, (heightMap[i][j], i, j))
+                
+        while pq:
+            h, i, j = heapq.heappop(pq)
+            if (i, j) in visited: continue
+            visited.add((i, j))
+            
+            if h>curr: curr = h
+            ans += (curr-h)
+            
+            for iNext, jNext in [(i+1, j), (i-1, j), (i, j+1), (i, j-1)]:
+                if iNext<0 or iNext>=N or jNext<0 or jNext>=M: continue
+                if (iNext, jNext) in visited: continue
+                heapq.heappush(pq, (heightMap[iNext][jNext], iNext, jNext))
+        
+        return ans
\ No newline at end of file
diff --git a/problems/trapping-rain-water.py b/problems/python/trapping-rain-water.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/trapping-rain-water.py
rename to problems/python/trapping-rain-water.py
diff --git a/problems/trim-a-binary-search-tree.py b/problems/python/trim-a-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/trim-a-binary-search-tree.py
rename to problems/python/trim-a-binary-search-tree.py
diff --git a/problems/python/two-out-of-three.py b/problems/python/two-out-of-three.py
new file mode 100755
index 0000000..8518903
--- /dev/null
+++ b/problems/python/two-out-of-three.py
@@ -0,0 +1,17 @@
+class Solution(object):
+    def twoOutOfThree(self, nums1, nums2, nums3):
+        ans = []
+        
+        counter = collections.Counter()
+        
+        for num in list(set(nums1)):
+            counter[num] += 1
+        for num in list(set(nums2)):
+            counter[num] += 1
+        for num in list(set(nums3)):
+            counter[num] += 1
+        
+        for num in counter:
+            if counter[num]>=2: ans.append(num)
+        
+        return ans
\ No newline at end of file
diff --git a/problems/two-sum-ii-input-array-is-sorted.py b/problems/python/two-sum-ii-input-array-is-sorted.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/two-sum-ii-input-array-is-sorted.py
rename to problems/python/two-sum-ii-input-array-is-sorted.py
diff --git a/problems/two-sum.py b/problems/python/two-sum.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/two-sum.py
rename to problems/python/two-sum.py
diff --git a/problems/ugly-number-ii.py b/problems/python/ugly-number-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/ugly-number-ii.py
rename to problems/python/ugly-number-ii.py
diff --git a/problems/ugly-number.py b/problems/python/ugly-number.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/ugly-number.py
rename to problems/python/ugly-number.py
diff --git a/problems/umber-of-islands-ii.py b/problems/python/umber-of-islands-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/umber-of-islands-ii.py
rename to problems/python/umber-of-islands-ii.py
diff --git a/problems/unique-binary-search-trees-ii,py b/problems/python/unique-binary-search-trees-ii,py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/unique-binary-search-trees-ii,py
rename to problems/python/unique-binary-search-trees-ii,py
diff --git a/problems/unique-binary-search-trees.py b/problems/python/unique-binary-search-trees.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/unique-binary-search-trees.py
rename to problems/python/unique-binary-search-trees.py
diff --git a/problems/unique-email-addres.py b/problems/python/unique-email-addres.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/unique-email-addres.py
rename to problems/python/unique-email-addres.py
diff --git a/problems/unique-paths.py b/problems/python/unique-paths.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/unique-paths.py
rename to problems/python/unique-paths.py
diff --git a/problems/univalued-binary-tree.py b/problems/python/univalued-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/univalued-binary-tree.py
rename to problems/python/univalued-binary-tree.py
diff --git a/problems/valid-anagram.py b/problems/python/valid-anagram.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/valid-anagram.py
rename to problems/python/valid-anagram.py
diff --git a/problems/python/valid-number.py b/problems/python/valid-number.py
new file mode 100755
index 0000000..9d0793a
--- /dev/null
+++ b/problems/python/valid-number.py
@@ -0,0 +1,44 @@
+class Solution(object):
+    def isNumber(self, s):
+        def isOK(s, maxDots):
+            if not s: return False
+            
+            #check and remove +/-
+            for i, c in enumerate(s):
+                if (c=='+' or c=='-') and i!=0:
+                    return False
+            if s[0]=='+' or s[0]=='-': s = s[1:]
+            
+            #check dot and if there is digit
+            dotCount = 0
+            dotPos = 0
+            digitCount = 0
+            for i, c in enumerate(s):
+                if c=='.':
+                    dotCount += 1
+                    dotPos = i
+                elif c.isdigit():
+                    digitCount += 1
+            
+            if dotCount>maxDots: return False
+            if digitCount==0: return False
+            
+            return True
+        
+        #get e's position. Also check if all char is in validChar
+        validChar = set(['1','2', '3', '4', '5', '6', '7', '8', '9', '0', 'e', 'E', '.', '+', '-'])
+        eCount = 0
+        ePos = 0
+        for i, c in enumerate(s):
+            if c not in validChar:
+                return False
+            if c=='e' or c=='E':
+                eCount += 1
+                ePos = i
+            
+        if eCount>1:
+            return False
+        elif eCount==1:
+            return isOK(s[:ePos], 1) and isOK(s[ePos+1:], 0)
+        else:
+            return isOK(s, 1)
diff --git a/problems/python/valid-palindrome-ii.py b/problems/python/valid-palindrome-ii.py
new file mode 100755
index 0000000..84bce52
--- /dev/null
+++ b/problems/python/valid-palindrome-ii.py
@@ -0,0 +1,29 @@
+"""
+When seeing the first different chars in the string.
+Check if anyone of the string is palindrome if we remove one of them.
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def validPalindrome(self, s):
+        def isPalindrome(s):
+            i = 0
+            j = len(s)-1
+            while i<j:
+                if s[i]!=s[j]: return False
+                i += 1
+                j -= 1
+            return True
+        
+        i = 0
+        j = len(s)-1
+        
+        while i<j:
+            if s[i]==s[j]:
+                i += 1
+                j -= 1
+            else:
+                return isPalindrome(s[i:j]) or isPalindrome(s[i+1:j+1])
+            
+        return True
\ No newline at end of file
diff --git a/problems/valid-palindrome.py b/problems/python/valid-palindrome.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/valid-palindrome.py
rename to problems/python/valid-palindrome.py
diff --git a/problems/valid-parentheses.py b/problems/python/valid-parentheses.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/valid-parentheses.py
rename to problems/python/valid-parentheses.py
diff --git a/problems/python/valid-word-abbreviation.py b/problems/python/valid-word-abbreviation.py
new file mode 100755
index 0000000..630f1b2
--- /dev/null
+++ b/problems/python/valid-word-abbreviation.py
@@ -0,0 +1,30 @@
+class Solution(object):
+    def validWordAbbreviation(self, word, abbr):
+        #process abbr
+        splitedAbbr = []
+        for c in abbr:
+            if c.isdigit() and splitedAbbr and splitedAbbr[-1][0].isdigit():
+                splitedAbbr[-1] += c
+            elif c.isdigit() and c=='0':
+                return False #leading 0
+            else:
+                splitedAbbr.append(c)
+        for i, c in enumerate(splitedAbbr):
+            if c[0].isdigit(): splitedAbbr[i] = int(c)
+                    
+        i = 0
+        j = 0
+        while i<len(word) and j<len(splitedAbbr):
+            if word[i]==splitedAbbr[j]:
+                i += 1
+                j += 1
+                continue
+            
+            if isinstance(splitedAbbr[j], basestring):
+                return False
+            else:
+                splitedAbbr[j] -= 1
+                if splitedAbbr[j]==0: j += 1
+                i += 1
+        
+        return i==len(word) and j==len(splitedAbbr)
\ No newline at end of file
diff --git a/problems/validate-binary-search-tree.py b/problems/python/validate-binary-search-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/validate-binary-search-tree.py
rename to problems/python/validate-binary-search-tree.py
diff --git a/problems/verify-preorder-serialization-of-a-binary-tree.py b/problems/python/verify-preorder-serialization-of-a-binary-tree.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/verify-preorder-serialization-of-a-binary-tree.py
rename to problems/python/verify-preorder-serialization-of-a-binary-tree.py
diff --git a/problems/python/vertical-order-traversal-of-a-binary-tree.py b/problems/python/vertical-order-traversal-of-a-binary-tree.py
new file mode 100755
index 0000000..bda15ad
--- /dev/null
+++ b/problems/python/vertical-order-traversal-of-a-binary-tree.py
@@ -0,0 +1,67 @@
+"""
+The description wants us to report from left to right, top to bottom.
+Thus, we keep add value into `temp` with `x_position` as the key and `(y_position, node.val)` as the value.
+And maintain `min_x`, `max_x` at the same time. So we know how to iterate the `temp`.
+"""
+from collections import defaultdict
+
+class Solution(object):
+    def verticalTraversal(self, root):
+        temp = defaultdict(list)
+        min_x = 0
+        max_x = 0
+
+        stack = []
+        stack.append((root, 0, 0))
+        while stack:
+            node, x, y = stack.pop()
+            temp[x].append((y, node.val)) #append the value of height, so we can sort by height later on
+            min_x = min(min_x, x)
+            max_x = max(max_x, x)
+            if node.left: stack.append((node.left, x-1, y+1))
+            if node.right: stack.append((node.right, x+1, y+1))
+        
+        opt = []
+        for i in range(min_x, max_x+1):
+            opt.append([v for y, v in sorted(temp[i])]) #the temp[i] will be sorted by y_position then sorted by node.val
+        
+        return opt
+
+
+"""
+Time: O(Nk) in average case.
+dfs takes O(N).
+Double for-loop take nearly O(N), in the double for-loop we need to spend some time on sorting.
+But the number of elements in the same column and row is very very small. Lets say, O(k)
+
+Space: O(N)
+"""
+class Solution(object):
+    def verticalTraversal(self, root):
+        def dfs(node, x, y):
+            if not node: return
+            self.maxX = max(self.maxX, x)
+            self.minX = min(self.minX, x)
+            self.minY = min(self.minY, y)
+            data[(x, y)].append(node.val)
+            dfs(node.left, x-1, y-1)
+            dfs(node.right, x+1, y-1)
+        
+        data = collections.defaultdict(list)
+        self.maxX = float('-inf')
+        self.minX = float('inf')
+        self.minY = float('inf')
+        
+        dfs(root, 0, 0)
+        
+        ans = []
+        for x in xrange(self.minX, self.maxX+1):
+            temp = []
+            for y in xrange(0, self.minY-1, -1):
+                if (x, y) not in data: continue
+                if len(data[(x, y)])>1:
+                    temp += sorted(data[(x, y)])
+                else:
+                    temp.append(data[(x, y)][0])
+            ans.append(temp)
+        return ans
\ No newline at end of file
diff --git a/problems/wiggle-subsequence.py b/problems/python/wiggle-subsequence.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/wiggle-subsequence.py
rename to problems/python/wiggle-subsequence.py
diff --git a/problems/word-break.py b/problems/python/word-break.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/word-break.py
rename to problems/python/word-break.py
diff --git a/problems/word-ladder-ii.py b/problems/python/word-ladder-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/word-ladder-ii.py
rename to problems/python/word-ladder-ii.py
diff --git a/problems/word-ladder.py b/problems/python/word-ladder.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/word-ladder.py
rename to problems/python/word-ladder.py
diff --git a/problems/word-search-ii.py b/problems/python/word-search-ii.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/word-search-ii.py
rename to problems/python/word-search-ii.py
diff --git a/problems/word-search.py b/problems/python/word-search.py
old mode 100644
new mode 100755
similarity index 100%
rename from problems/word-search.py
rename to problems/python/word-search.py
diff --git a/problems/python3/3sum-closest.py b/problems/python3/3sum-closest.py
new file mode 100755
index 0000000..472c80f
--- /dev/null
+++ b/problems/python3/3sum-closest.py
@@ -0,0 +1,24 @@
+"""
+Time: O(N^2)
+Space: O(1)
+"""
+class Solution:
+    def threeSumClosest(self, nums: List[int], target: int) -> int:
+        nums.sort()
+        
+        N = len(nums)
+        ans = float('inf')
+        
+        for i in range(N):
+            j = i+1
+            k = N-1
+            
+            while j<k:
+                total = nums[i]+nums[j]+nums[k]
+                if total==target: return total
+                if abs(target-ans)>abs(target-total): ans = total
+                if total>target:
+                    k -= 1
+                elif total<target:
+                    j += 1
+        return ans
\ No newline at end of file
diff --git a/problems/python3/3sum-smaller.py b/problems/python3/3sum-smaller.py
new file mode 100755
index 0000000..3291586
--- /dev/null
+++ b/problems/python3/3sum-smaller.py
@@ -0,0 +1,18 @@
+class Solution:
+    def threeSumSmaller(self, nums: List[int], target: int) -> int:
+        N = len(nums)
+        ans = 0
+        
+        nums.sort()
+        
+        
+        for i in range(N):
+            j = i+1
+            k = N-1
+            while j<k:
+                if nums[i]+nums[j]+nums[k]<target:
+                    ans += k-j
+                    j += 1
+                else:
+                    k -= 1
+        return ans
\ No newline at end of file
diff --git a/problems/python3/3sum.py b/problems/python3/3sum.py
new file mode 100755
index 0000000..97f3388
--- /dev/null
+++ b/problems/python3/3sum.py
@@ -0,0 +1,92 @@
+"""
+Time: O(N^2)
+Space: O(1)
+
+First of all, we need to sort the list, so that it is easier to know where to move the pointers.
+(Keep in mind that sorting takes O(NLogN) of time, but since judging from the problem this solution might takes at least O(N^2), so it is ok to sort.)
+
+Now, we have 3 unique pointers at the list. i, j, k, where i<j<k.
+For a given i, set j at i+1 and k at the rightest.
+
+If the sum is too large, our only option is to move k left, so we can find smaller sum.
+If the sum is too small, our only option is to move j right, so we can find larger sum.
+If the sum is what we want, add it to the ans.
+
+[0] we need to skip the num that is the same as the last one to remove duplicate. This is actually the hardest part of the problem.
+[1] if nums[i] is larger than 0, we can stop, since nums[i] and nums[k] are surely larger than nums[i]
+"""
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        ans = []
+        nums.sort()
+        
+        for i in range(len(nums)):
+            if 0<i and nums[i]==nums[i-1]: continue #[0]
+            if nums[i]>0: break #[1]
+            
+            j, k = i+1, len(nums)-1
+            while j<k:
+                if nums[i]+nums[j]+nums[k]>0:
+                    k -= 1
+                elif nums[i]+nums[j]+nums[k]<0:
+                    j += 1
+                else:
+                    ans.append((nums[i], nums[j], nums[k]))
+                    while 0<k-1 and nums[k-1]==nums[k]: k -= 1 #[0]
+                    while j+1<len(nums) and nums[j+1]==nums[j]: j += 1 #[0]
+                    k -= 1
+                    j += 1
+                    
+        return ans
+
+
+"""
+No Sort.
+Use set to dedupe and check needed.
+
+Time: O(N^2)
+Space: O(N)
+"""
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        ans = set()
+        seen = set()
+        N = len(nums)
+        
+        for i, v1 in enumerate(nums):
+            if v1 in seen: continue
+            seen.add(v1)
+            needed = set()
+            for j, v2 in enumerate(nums[i+1:]):
+                if v2 in needed:
+                    ans.add(tuple(sorted((v1, v2, -v1-v2))))
+                needed.add(-v1-v2)
+        return ans
+
+
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        ans = []
+        
+        nums.sort()
+        
+        for i in range(len(nums)):
+            if nums[i]>0: break
+            if i>0 and nums[i]==nums[i-1]: continue
+            
+            j = i+1
+            k = len(nums)-1
+            while j<k:
+                if nums[j]+nums[k]+nums[i]>0:
+                    k -= 1
+                elif nums[j]+nums[k]+nums[i]<0:
+                    j += 1
+                else:
+                    ans.append((nums[i], nums[j], nums[k]))
+                    
+                    while j<k and nums[j+1]==nums[j]: j += 1
+                    while j<k and nums[k-1]==nums[k]: k -= 1
+                    j += 1
+                    k -= 1
+        return ans
\ No newline at end of file
diff --git a/problems/python3/4sum.py b/problems/python3/4sum.py
new file mode 100755
index 0000000..4757233
--- /dev/null
+++ b/problems/python3/4sum.py
@@ -0,0 +1,33 @@
+"""
+Time: O(N^(K-1)) -> O(N^3)
+Space: O(K) -> O(1)
+"""
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        def kSum(k, start, target):
+            if k>2:
+                for i in range(start, len(nums)-k+1):
+                    if i!=start and nums[i]==nums[i-1]: continue
+                    temp.append(nums[i])
+                    kSum(k-1, i+1, target-nums[i])
+                    temp.pop()
+            else:
+                l, r = start, len(nums)-1
+                
+                while l<r:
+                    if nums[l]+nums[r]>target:
+                        r -= 1
+                    elif nums[l]+nums[r]<target:
+                        l += 1
+                    else:
+                        ans.append(temp+[nums[l], nums[r]])
+                        while l<r and nums[l+1]==nums[l]: l += 1
+                        while l<r and nums[r-1]==nums[r]: r -= 1
+                        l += 1
+                        r -= 1
+                        
+        ans = []
+        temp = []
+        nums.sort()
+        kSum(4, 0, target)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/add-two-numbers.py b/problems/python3/add-two-numbers.py
new file mode 100644
index 0000000..ed9dee4
--- /dev/null
+++ b/problems/python3/add-two-numbers.py
@@ -0,0 +1,19 @@
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        carry = 0
+        dummy = ListNode()
+        curr = dummy
+        
+        while l1 or l2 or carry:
+            n = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry
+            if n>=10:
+                curr.next = ListNode(n-10)
+                carry = 1
+            else:
+                curr.next = ListNode(n)
+                carry = 0
+            curr = curr.next
+            if l1: l1 = l1.next
+            if l2: l2 = l2.next
+            
+        return dummy.next
\ No newline at end of file
diff --git a/problems/python3/alien-dictionary.py b/problems/python3/alien-dictionary.py
new file mode 100644
index 0000000..23ca1ee
--- /dev/null
+++ b/problems/python3/alien-dictionary.py
@@ -0,0 +1,36 @@
+class Solution:
+    def alienOrder(self, words: List[str]) -> str:
+        adj = collections.defaultdict(list)
+        inbounds = collections.Counter()
+        q = collections.deque()
+        ans = ''
+        
+        adj = {c: set() for word in words for c in word}
+        for i in range(len(words)-1):
+            w1, w2 = words[i], words[i+1]
+            minLen = min(len(w1), len(w2))
+            if w1[:minLen]==w2[:minLen] and len(w1)>len(w2): return ""
+            
+            for j in range(minLen):
+                if w1[j]!=w2[j]:
+                    adj[w1[j]].add(w2[j])
+                    break
+        
+        for c in adj:
+            for nc in list(adj[c]):
+                inbounds[nc] += 1
+        
+        for c in adj:
+            if inbounds[c]==0: q.append(c)
+        
+        while q:
+            c = q.popleft()
+            
+            ans += c
+            
+            for nc in adj[c]:
+                inbounds[nc] -= 1
+                if inbounds[nc]==0: q.append(nc)
+        
+        return ans if len(ans)==len(adj) else ''
+
diff --git a/problems/python3/balanced-binary-tree.py b/problems/python3/balanced-binary-tree.py
new file mode 100755
index 0000000..65c749e
--- /dev/null
+++ b/problems/python3/balanced-binary-tree.py
@@ -0,0 +1,18 @@
+"""
+Time: O(N)
+Space: O(LogN) Recursion stack. If the tree is balanced.
+"""
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        def getHeight(node) -> (bool, int):
+            if not node: return True, 0
+            leftIsBalanced, leftHeight = getHeight(node.left)
+            if not leftIsBalanced: return False, 0
+            
+            rightIsBalanced, rightHeight = getHeight(node.right)
+            if not rightIsBalanced: return False, 0
+            
+            return abs(leftHeight-rightHeight)<2, 1+max(leftHeight, rightHeight)
+        
+        isBalanced, h = getHeight(root)
+        return isBalanced
\ No newline at end of file
diff --git a/problems/python3/best-time-to-buy-and-sell-stock-with-cooldown.py b/problems/python3/best-time-to-buy-and-sell-stock-with-cooldown.py
new file mode 100644
index 0000000..06644e3
--- /dev/null
+++ b/problems/python3/best-time-to-buy-and-sell-stock-with-cooldown.py
@@ -0,0 +1,16 @@
+#dp[i][0] := max profit when last action is buy
+#dp[i][1] := max profit when last action is sell
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        if not prices or len(prices)<=1: return 0
+        
+        N = len(prices)
+        dp = [[0, 0] for _ in range(N)]
+        dp[0] = [-prices[0], 0]
+        dp[1][0] = max(-prices[1], -prices[0])
+        dp[1][1] = max(prices[1]+dp[0][0], dp[0][1])
+        
+        for i in range(2, N):
+            dp[i][0] = max(dp[i-2][1]-prices[i], dp[i-1][0])
+            dp[i][1] = max(prices[i]+dp[i-1][0], dp[i-1][1])
+        return max(dp[-1][0], dp[-1][1], 0)
\ No newline at end of file
diff --git a/problems/python3/best-time-to-buy-and-sell-stock.py b/problems/python3/best-time-to-buy-and-sell-stock.py
new file mode 100644
index 0000000..f04ad91
--- /dev/null
+++ b/problems/python3/best-time-to-buy-and-sell-stock.py
@@ -0,0 +1,10 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        minPrice = prices[0]
+        ans = 0
+        
+        for i in range(1, len(prices)):
+            ans = max(ans, prices[i]-minPrice)
+            minPrice = min(prices[i], minPrice)
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python3/binary-search.py b/problems/python3/binary-search.py
new file mode 100644
index 0000000..2e65a63
--- /dev/null
+++ b/problems/python3/binary-search.py
@@ -0,0 +1,16 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        l = 0
+        r = len(nums)-1
+        
+        while l<=r:
+            m = l + int((r-l)/2)
+            
+            if nums[m]>target:
+                r = m-1
+            elif nums[m]<target:
+                l = m+1
+            else:
+                return m
+        
+        return -1
\ No newline at end of file
diff --git a/problems/python3/binary-tree-level-order-traversal.py b/problems/python3/binary-tree-level-order-traversal.py
new file mode 100755
index 0000000..2ddb875
--- /dev/null
+++ b/problems/python3/binary-tree-level-order-traversal.py
@@ -0,0 +1,39 @@
+"""
+Time: O(N), since we need to go through all the nodes.
+Space: O(LogN) for recursion stack. (if the tree is balanced). This do not take the output into account.
+"""
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        def helper(node, level):
+            if not node: return
+            if level==len(ans): ans.append([])
+            ans[level].append(node.val)
+            helper(node.left, level+1)
+            helper(node.right, level+1)
+        
+        ans = []
+        helper(root, 0)
+        
+        return ans
+
+
+"""
+Time: O(N), since we need to go through all the nodes.
+Space: O(N) for queue.
+"""
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if not root: return []
+        
+        q = collections.deque([(root, 0)])
+        ans = []
+        
+        while q:
+            node, level = q.popleft()
+            
+            if level==len(ans): ans.append([])
+            ans[level].append(node.val)
+            if node.left: q.append((node.left, level+1))
+            if node.right: q.append((node.right, level+1))
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python3/binary-tree-maximum-path-sum.py b/problems/python3/binary-tree-maximum-path-sum.py
new file mode 100644
index 0000000..e024506
--- /dev/null
+++ b/problems/python3/binary-tree-maximum-path-sum.py
@@ -0,0 +1,27 @@
+"""
+helper(node) will return the max path sum from the node to the leaf. [0]
+
+Along the way we update the ans. [1]
+The path of ans must pass through one of the node in the tree.
+`node.val+left+right` means the max path sum that pass through the node.
+So after all `helper()` is executed, we tested all the nodes.
+
+Since there are some negative values in the tree, each node can decided not to take the negative path sum into account. [3]
+
+Time: O(N)
+Space: O(LogN) for the recursive stack (if the tree is balanced).
+"""
+class Solution:
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+        def helper(node):
+            nonlocal ans
+            
+            if not node: return 0
+            left = max(helper(node.left), 0) #[3]
+            right = max(helper(node.right), 0) #[3]
+            ans = max(ans, node.val+left+right) #[1]
+            return node.val+max(left, right) #[0]
+        
+        ans = float('-inf')
+        helper(root)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/binary-tree-right-side-view.py b/problems/python3/binary-tree-right-side-view.py
new file mode 100755
index 0000000..53b4d13
--- /dev/null
+++ b/problems/python3/binary-tree-right-side-view.py
@@ -0,0 +1,18 @@
+"""
+Time: O(N)
+Space: O(LogN) if the tree is balanced.
+
+BFS is a more intuitive way to do this, but the time complexity will be at least O(N).
+Using recursion instead, will take O(LogN) for the recursion stack size.
+"""
+class Solution:
+    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
+        def helper(node, level):
+            if not node: return
+            if len(ans)<level: ans.append(node.val)
+            helper(node.right, level+1)
+            helper(node.left, level+1)
+        
+        ans = []
+        helper(root, 1)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/burst-balloons.py b/problems/python3/burst-balloons.py
new file mode 100644
index 0000000..aae31be
--- /dev/null
+++ b/problems/python3/burst-balloons.py
@@ -0,0 +1,28 @@
+"""
+dfs(l, r) return the max coins that we can get at range l to r.
+
+```
+for i in range(l, r+1):
+    dp[(l, r)] = max(dp[(l, r)], nums[l-1]*nums[i]*nums[r+1] + dfs(l, i-1) + dfs(i+1, r))
+```
+Assuming i is the last one we extract, the max coins we can get.
+
+Start from the last becasue, we are not able to track the neighbor if we start from the first we extract.
+
+Time: O(N^3)
+Space: O(N^2)
+"""
+class Solution:
+    def maxCoins(self, nums: List[int]) -> int:
+        def dfs(l, r)->int:
+            if l>r: return 0
+            if (l, r) in dp: return dp[(l, r)]
+            
+            dp[(l, r)] = 0
+            for i in range(l, r+1):
+                dp[(l, r)] = max(dp[(l, r)], nums[l-1]*nums[i]*nums[r+1] + dfs(l, i-1) + dfs(i+1, r))
+            return dp[(l, r)]
+                
+        nums = [1]+nums+[1]
+        dp = {}
+        return dfs(1, len(nums)-2)
\ No newline at end of file
diff --git a/problems/python3/car-fleet.py b/problems/python3/car-fleet.py
new file mode 100644
index 0000000..24ccba8
--- /dev/null
+++ b/problems/python3/car-fleet.py
@@ -0,0 +1,16 @@
+class Solution:
+    def carFleet(self, target: int, position: List[int], speed: List[int]) -> int:
+        N = len(position)
+        
+        timeInfo = []
+        for i in range(N):
+            timeInfo.append((position[i], (target-position[i])/speed[i]))
+        timeInfo.sort(reverse=True)
+        
+        stack = []
+        for _, time in timeInfo:
+            stack.append(time)
+            if len(stack)>=2 and stack[-2]>=stack[-1]:
+                stack.pop()
+        
+        return len(stack)
\ No newline at end of file
diff --git a/problems/python3/cheapest-flights-within-k-stops.py b/problems/python3/cheapest-flights-within-k-stops.py
new file mode 100644
index 0000000..4595802
--- /dev/null
+++ b/problems/python3/cheapest-flights-within-k-stops.py
@@ -0,0 +1,17 @@
+"""
+Bellman-Ford.
+Time: O(KE)
+"""
+class Solution:
+    def findCheapestPrice(self, N: int, flights: List[List[int]], src: int, dst: int, K: int) -> int:
+        prices = {n:float('inf') for n in range(N)}
+        prices[src] = 0
+        
+        for k in range(K+1):
+            temp = prices.copy()
+            for source, destination, price in flights:
+                if prices[source]==float('inf'): continue
+                if prices[source]+price<temp[destination]:
+                    temp[destination] = prices[source]+price
+            prices = temp
+        return prices[dst] if prices[dst]!=float('inf') else -1
\ No newline at end of file
diff --git a/problems/python3/climbing-stairs.py b/problems/python3/climbing-stairs.py
new file mode 100644
index 0000000..5dc281b
--- /dev/null
+++ b/problems/python3/climbing-stairs.py
@@ -0,0 +1,10 @@
+class Solution:
+    def climbStairs(self, N: int) -> int:
+        dp = [0]*(N+1)
+        dp[0] = 1
+        for i in range(len(dp)):
+            if i-1>=0:
+                dp[i] += dp[i-1]
+            if i-2>=0:
+                dp[i] += dp[i-2]
+        return dp[-1]
\ No newline at end of file
diff --git a/problems/python3/clone-graph.py b/problems/python3/clone-graph.py
new file mode 100644
index 0000000..9a6765f
--- /dev/null
+++ b/problems/python3/clone-graph.py
@@ -0,0 +1,16 @@
+class Solution:
+    def cloneGraph(self, start: 'Node') -> 'Node':
+        def dfs(node):
+            if node in clones: return clones[node]
+            
+            copy = Node(node.val)
+            clones[node] = copy
+            
+            for neighbor in node.neighbors:
+                copy.neighbors.append(dfs(neighbor))
+                
+            return clones[node]
+        if not start: return start
+        clones = {}
+        dfs(start)
+        return clones[start]
\ No newline at end of file
diff --git a/problems/python3/coin-change-ii.py b/problems/python3/coin-change-ii.py
new file mode 100644
index 0000000..8b4ad26
--- /dev/null
+++ b/problems/python3/coin-change-ii.py
@@ -0,0 +1,12 @@
+class Solution:
+    def change(self, amount: int, coins: List[int]) -> int:
+        dp = [0]*(amount+1)
+        dp[0] = 1
+        
+        coins.sort()
+        
+        for coin in coins:
+            for a in range(1, amount+1):
+                if a-coin<0: continue
+                dp[a] += dp[a-coin]
+        return dp[-1]
\ No newline at end of file
diff --git a/problems/python3/coin-change.py b/problems/python3/coin-change.py
new file mode 100644
index 0000000..19571e4
--- /dev/null
+++ b/problems/python3/coin-change.py
@@ -0,0 +1,14 @@
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        dp = [float('inf')]*(amount+1)
+        dp[0] = 0
+        for coin in coins:
+            if coin<len(dp): dp[coin] = 1
+        
+        coins.sort()
+        
+        for i in range(1, amount+1):
+            for coin in coins:
+                if i-coin<0: break
+                dp[i] = min(dp[i], dp[i-coin]+1)
+        return dp[amount] if dp[amount]!=float('inf') else -1
\ No newline at end of file
diff --git a/problems/python3/combination-sum-ii.py b/problems/python3/combination-sum-ii.py
new file mode 100644
index 0000000..c9f8957
--- /dev/null
+++ b/problems/python3/combination-sum-ii.py
@@ -0,0 +1,22 @@
+class Solution:
+    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
+        def helper(i, target):
+            if target==0:
+                ans.append(combination.copy())
+                return
+            
+            if i==len(candidates) or candidates[i]>target:
+                return
+            
+            combination.append(candidates[i])
+            helper(i+1, target-candidates[i])
+            combination.pop()
+            
+            while i+1<len(candidates) and candidates[i]==candidates[i+1]: i += 1
+            helper(i+1, target)
+        
+        ans = []
+        combination = []
+        candidates.sort()
+        helper(0, target)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/combination-sum.py b/problems/python3/combination-sum.py
new file mode 100644
index 0000000..256cefa
--- /dev/null
+++ b/problems/python3/combination-sum.py
@@ -0,0 +1,29 @@
+"""
+Time: O(N^K), assuming the number of element in the combination that sums up to "target" is K.
+For each element, there is N choices.
+Which means the number of combination is N*N*N... for K times.
+~= O(N^K)
+
+Space: O(K)
+
+K is approximate to target/min(candidates).
+"""
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        def helper(i, currSum, target):
+            if currSum>target:
+                return
+            
+            if currSum==target:
+                ans.append(combination.copy())
+                return
+            
+            for j in range(i, len(candidates)):
+                combination.append(candidates[j])
+                helper(j, currSum+candidates[j], target)
+                combination.pop()
+                
+        ans = []
+        combination = []
+        helper(0, 0, target)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/construct-binary-tree-from-preorder-and-inorder-traversal.py b/problems/python3/construct-binary-tree-from-preorder-and-inorder-traversal.py
new file mode 100644
index 0000000..eb7f19c
--- /dev/null
+++ b/problems/python3/construct-binary-tree-from-preorder-and-inorder-traversal.py
@@ -0,0 +1,34 @@
+"""
+preorder: [root][left][right]
+inorder:  [left][root][right]
+
+[0]
+As you can see, the root is always located at the first index of the preorder list.
+
+[2]
+Using the same logic, we can recursively get the left and right node
+Inorder to do that, we need to define left and right nodes' range.
+And we can get the length of the left subtree by locating the index of the root in the in order list. [1]
+i and j is the startIndex and the (endIndex+1) of the preorder list.
+k and l is the startIndex and the (endIndex+1) of the inorder list.
+
+Time: O(N)
+Space: O(N)
+"""
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        def helper(i, j, k, l):
+            if i==j or k==l: return None
+            
+            root = TreeNode(preorder[i]) #[0]
+            
+            rootInorderIndex = getInorderIndex[root.val] #[1]
+            leftLen = rootInorderIndex-k
+            
+            root.left = helper(i+1, i+1+leftLen, k, k+leftLen) #[2]
+            root.right = helper(i+1+leftLen, j, rootInorderIndex+1, l)
+            return root
+        
+        getInorderIndex = {}
+        for i, v in enumerate(inorder): getInorderIndex[v] = i
+        return helper(0, len(preorder), 0, len(inorder))
\ No newline at end of file
diff --git a/problems/python3/container-with-most-water.py b/problems/python3/container-with-most-water.py
new file mode 100755
index 0000000..a560441
--- /dev/null
+++ b/problems/python3/container-with-most-water.py
@@ -0,0 +1,42 @@
+"""
+Time: O(N)
+Space: O(1)
+
+i and j starts from the leftest and rightest. Move the one that has less height.
+
+Why we won't miss any i and j?
+For example, currently i is heigher than j.
+If between i~j, there are no height that is larger or equal to i, than since the area is `min(height[i], height[j]) * (j-i)`, you cannot find any area that is larger than the current one.
+If between i~j, there is a height that is larger or equal to i, j will on it, and it will be tested.
+Thus, given any i and j, any other future i and j that have the potential of forming larger area will be tested.
+"""
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        i = 0
+        j = len(height)-1
+        ans = 0
+        
+        while i<j:
+            ans = max(ans, min(height[i], height[j]) * (j-i))
+            if height[i]>height[j]:
+                j -= 1
+            else:
+                i += 1
+        return ans
+
+
+
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        i = 0
+        j = len(height)-1
+        ans = 0
+        
+        while i<j:
+            ans = max(ans, min(height[i], height[j]) * abs(i-j))
+            
+            if height[i]>height[j]:
+                j -= 1
+            else:
+                i += 1
+        return ans
\ No newline at end of file
diff --git a/problems/python3/contains-duplicate.py b/problems/python3/contains-duplicate.py
new file mode 100644
index 0000000..7849e84
--- /dev/null
+++ b/problems/python3/contains-duplicate.py
@@ -0,0 +1,7 @@
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        seen = set()
+        for num in nums:
+            if num in seen: return True
+            seen.add(num)
+        return False
\ No newline at end of file
diff --git a/problems/python3/copy-list-with-random-pointer.py b/problems/python3/copy-list-with-random-pointer.py
new file mode 100644
index 0000000..4436b78
--- /dev/null
+++ b/problems/python3/copy-list-with-random-pointer.py
@@ -0,0 +1,34 @@
+"""
+Time: O(N)
+Space: O(1)
+
+The easiest way would be maintaining a hash map for original node to the copy and the other way around. Then the rest is easy.
+But this will take us O(N) of extra space.
+
+Two pass solution with constant space.
+First pass.
+Create a copy of the original and store it inside "random".
+The copy points to original's next and original's random.
+
+Second pass.
+Iterate through the nodes again.
+This time we adjust the copy to point to the other copies.
+"""
+class Solution:
+    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+        if not head: return head
+        
+        node = head
+        while node:
+            copy = Node(node.val, node.next, node.random)
+            node.random = copy
+            node = node.next
+        
+        node = head
+        while node:
+            newNode = node.random
+            if node.next: newNode.next = node.next.random
+            if newNode.random: newNode.random = newNode.random.random
+            node = node.next
+        
+        return head.random
\ No newline at end of file
diff --git a/problems/python3/count-good-nodes-in-binary-tree.py b/problems/python3/count-good-nodes-in-binary-tree.py
new file mode 100755
index 0000000..2288d12
--- /dev/null
+++ b/problems/python3/count-good-nodes-in-binary-tree.py
@@ -0,0 +1,16 @@
+"""
+Time: O(N)
+Space: O(LogN) for recursion stack if the tree is balanced.
+"""
+class Solution:
+    def goodNodes(self, root: TreeNode) -> int:
+        def helper(node, maxVal):
+            nonlocal count            
+            if not node: return
+            if node.val>=maxVal: count += 1
+            helper(node.left, max(maxVal, node.val))
+            helper(node.right, max(maxVal, node.val))
+        
+        count = 0
+        helper(root, float('-inf'))
+        return count
\ No newline at end of file
diff --git a/problems/python3/counting-bits.py b/problems/python3/counting-bits.py
new file mode 100644
index 0000000..7325596
--- /dev/null
+++ b/problems/python3/counting-bits.py
@@ -0,0 +1,9 @@
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        ans = [0]*(n+1)
+        offset = 1
+        
+        for i in range(1, n+1):
+            if offset*2==i: offset = offset*2
+            ans[i] = 1+ans[i-offset]
+        return ans
\ No newline at end of file
diff --git a/problems/python3/course-schedule-ii.py b/problems/python3/course-schedule-ii.py
new file mode 100644
index 0000000..00725b4
--- /dev/null
+++ b/problems/python3/course-schedule-ii.py
@@ -0,0 +1,30 @@
+#Topological Sort
+class Solution:
+    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+        sortedCourse = []
+        G = collections.defaultdict(list) #graph
+        inbounds = collections.Counter()
+        q = collections.deque()
+        
+        #build graph
+        for c1, c2 in prerequisites:
+            G[c2].append(c1)
+            inbounds[c1] += 1
+        
+        #add the starting point to the q. (the ones that have 0 inbounds)
+        for course in range(numCourses):
+            if inbounds[course]==0: q.append(course)
+        
+        #add the course that have 0 inbounds to the sortedCourse.
+        #after that, imagine we remove it from the graph, so nextCourse inbound will -1
+        #add to q if nextCourse have 0 inbounds
+        while q:
+            course = q.popleft()
+            
+            sortedCourse.append(course)
+            
+            for nextCourse in G[course]:
+                inbounds[nextCourse] -= 1
+                if inbounds[nextCourse]==0: q.append(nextCourse)
+        
+        return sortedCourse if len(sortedCourse)==numCourses else []
\ No newline at end of file
diff --git a/problems/python3/course-schedule.py b/problems/python3/course-schedule.py
new file mode 100644
index 0000000..f52d07d
--- /dev/null
+++ b/problems/python3/course-schedule.py
@@ -0,0 +1,23 @@
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        sortedCourse = []
+        inbounds = collections.Counter()
+        G = collections.defaultdict(list)
+        q = collections.deque()
+        
+        for c1, c2 in prerequisites:
+            G[c2].append(c1)
+            inbounds[c1] += 1
+        
+        for c in range(numCourses):
+            if inbounds[c]==0: q.append(c)
+
+        while q:
+            c = q.popleft()
+            
+            for c2 in G[c]:
+                inbounds[c2] -= 1
+                if inbounds[c2]==0: q.append(c2)    
+            sortedCourse.append(c)
+        
+        return len(sortedCourse)==numCourses
\ No newline at end of file
diff --git a/problems/python3/daily-temperatures.py b/problems/python3/daily-temperatures.py
new file mode 100644
index 0000000..d6e4c98
--- /dev/null
+++ b/problems/python3/daily-temperatures.py
@@ -0,0 +1,12 @@
+class Solution:
+    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
+        ans = [0]*len(temperatures)
+        stack = []
+        
+        for i, temp in enumerate(temperatures):
+            while stack and stack[-1][0]<temp:
+                prevTemp, prevIndex = stack.pop()
+                ans[prevIndex] = i-prevIndex
+            stack.append((temp, i))
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python3/decode-ways.py b/problems/python3/decode-ways.py
new file mode 100644
index 0000000..3ac6c2d
--- /dev/null
+++ b/problems/python3/decode-ways.py
@@ -0,0 +1,14 @@
+"""
+dp[i] := up until s[:i] how many possibility?
+"""
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        mapping = set([str(n) for n in range(1, 27)])
+        N = len(s)
+        dp = [0]*(N+1)
+        dp[0] = 1
+        
+        for i in range(1, N+1):
+            if i-1>=0 and s[i-1] in mapping: dp[i] += dp[i-1]
+            if i-2>=0 and s[i-2:i] in mapping: dp[i] += dp[i-2]
+        return dp[-1]
\ No newline at end of file
diff --git a/problems/python3/design-add-and-search-words-data-structure.py b/problems/python3/design-add-and-search-words-data-structure.py
new file mode 100644
index 0000000..52effc8
--- /dev/null
+++ b/problems/python3/design-add-and-search-words-data-structure.py
@@ -0,0 +1,33 @@
+class WordDictionary:
+
+    def __init__(self):
+        self.root = {}
+
+    def addWord(self, word: str) -> None:
+        node = self.root
+        for c in word:
+            if c not in node: node[c] = {}
+            node = node[c]
+        node['$'] = {} #'.' means the end of the word
+
+    def search(self, word: str) -> bool:
+        def helper(node, i):
+            if i==len(word): return '$' in node
+                
+            if word[i]=='.':
+                for c in node:
+                    if helper(node[c], i+1): return True
+                return False
+            else:
+                if word[i] not in node: return False
+                return helper(node[word[i]], i+1)
+        return helper(self.root, 0)
+            
+        
+        
+        
+        
+    
+    
+    
+    
\ No newline at end of file
diff --git a/problems/python3/design-twitter.py b/problems/python3/design-twitter.py
new file mode 100644
index 0000000..a2781ae
--- /dev/null
+++ b/problems/python3/design-twitter.py
@@ -0,0 +1,49 @@
+class Twitter:
+
+    def __init__(self):
+        self.followData = collections.defaultdict(set)
+        self.tweetData = collections.defaultdict(list)
+        self.count = 0
+        
+
+    def postTweet(self, userId: int, tweetId: int) -> None:
+        self.tweetData[userId].append((self.count, tweetId))
+        self.count -= 1
+
+    
+    def getNewsFeed(self, userId: int) -> List[int]:
+        newsFeed = []
+        h = []
+        
+        self.followData[userId].add(userId)
+        for followeeId in self.followData[userId]:
+            if followeeId not in self.tweetData: continue
+            index = len(self.tweetData[followeeId])-1
+            count, tweetId = self.tweetData[followeeId][index]
+            h.append((count, tweetId, followeeId, index-1))
+        heapq.heapify(h)
+        
+        while h and len(newsFeed)<10:
+            _, tweetId, userId, index = heapq.heappop(h)
+            newsFeed.append(tweetId)
+            if index>=0:
+                count, tweetId2 = self.tweetData[userId][index]
+                heapq.heappush(h, (count, tweetId2, userId, index-1))
+        return newsFeed
+        
+        
+
+    def follow(self, followerId: int, followeeId: int) -> None:
+        self.followData[followerId].add(followeeId)
+
+    def unfollow(self, followerId: int, followeeId: int) -> None:
+        if followerId not in self.followData: return
+        self.followData[followerId].remove(followeeId)
+
+
+# Your Twitter object will be instantiated and called as such:
+# obj = Twitter()
+# obj.postTweet(userId,tweetId)
+# param_2 = obj.getNewsFeed(userId)
+# obj.follow(followerId,followeeId)
+# obj.unfollow(followerId,followeeId)
\ No newline at end of file
diff --git a/problems/python3/detect-squares.py b/problems/python3/detect-squares.py
new file mode 100644
index 0000000..af86946
--- /dev/null
+++ b/problems/python3/detect-squares.py
@@ -0,0 +1,22 @@
+class DetectSquares:
+
+    def __init__(self):
+        self.store = collections.Counter()
+
+    def add(self, point: List[int]) -> None:
+        self.store[tuple(point)] += 1
+
+    def count(self, point: List[int]) -> int:
+        x, y = point
+        ans = 0
+        
+        for dx, dy in self.store:
+            if abs(x-dx)!=abs(y-dy) or x==dx or y==dy: continue
+            ans += self.store[(dx, dy)]*self.store[(dx, y)]*self.store[(x, dy)]
+        return ans
+
+
+# Your DetectSquares object will be instantiated and called as such:
+# obj = DetectSquares()
+# obj.add(point)
+# param_2 = obj.count(point)
\ No newline at end of file
diff --git a/problems/python3/diameter-of-binary-tree.py b/problems/python3/diameter-of-binary-tree.py
new file mode 100755
index 0000000..1f9704d
--- /dev/null
+++ b/problems/python3/diameter-of-binary-tree.py
@@ -0,0 +1,17 @@
+"""
+Time: O(N)
+Space: O(LogN) for the recursion stack. If the tree is balanced.
+"""
+class Solution:
+    def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
+        def helper(node):
+            if not node: return 0
+            l = helper(node.left)
+            r = helper(node.right)
+            self.ans = max(self.ans, 1+l+r)
+            return 1+max(l, r)
+        
+        self.ans = 0
+        
+        helper(root)
+        return self.ans-1
\ No newline at end of file
diff --git a/problems/python3/distinct-subsequences.py b/problems/python3/distinct-subsequences.py
new file mode 100644
index 0000000..d84fcf6
--- /dev/null
+++ b/problems/python3/distinct-subsequences.py
@@ -0,0 +1,17 @@
+class Solution:
+    def numDistinct(self, s: str, t: str) -> int:
+        def dfs(i, j):
+            if (i, j) in visited: return visited[(i, j)]
+            
+            if j>=len(t): return 1
+            if i>=len(s): return 0
+            
+            if s[i]==t[j]:
+                visited[(i, j)] = dfs(i+1, j+1)+dfs(i+1, j)
+            else:
+                visited[(i, j)] = dfs(i+1, j)
+            return visited[(i, j)]
+            
+        visited = {}
+        dfs(0, 0)
+        return dfs(0, 0)
\ No newline at end of file
diff --git a/problems/python3/edit-distance.py b/problems/python3/edit-distance.py
new file mode 100644
index 0000000..c8fa8f4
--- /dev/null
+++ b/problems/python3/edit-distance.py
@@ -0,0 +1,37 @@
+"""
+dfs(i, j)
+i being the unprocessed index in word1.
+j, word2.
+
+MAIN LOGIC:
+if word1[i]==word2[j], no operation need, return dfs(i+1, j+1)
+if not, need 1 operation, so
+replace: dfs(i+1, j+1)
+insert: dfs(i, j+1)
+delete: dfs(i+1, j)
+
+BASE CASE:
+If both string are empty (i==N and j==M), no operation needed.
+If one string are empty, then the remain operation is the length of the non-empty one.
+"""
+class Solution:
+    def minDistance(self, word1: str, word2: str) -> int:
+        N = len(word1)
+        M = len(word2)
+        def dfs(i, j)->int:
+            if i==N and j==M: return 0
+            if i==N: return M-j
+            if j==M: return N-i
+            
+            if (i, j) in history:
+                return history[(i, j)]
+                
+            if word1[i]==word2[j]:
+                history[(i, j)] = dfs(i+1, j+1)
+            else:
+                history[(i, j)] = 1+min(dfs(i+1, j+1), dfs(i+1, j), dfs(i, j+1))
+            
+            return history[(i, j)]
+        
+        history = {}
+        return dfs(0, 0)
\ No newline at end of file
diff --git a/problems/python3/encode-and-decode-strings.py b/problems/python3/encode-and-decode-strings.py
new file mode 100644
index 0000000..f38c4e4
--- /dev/null
+++ b/problems/python3/encode-and-decode-strings.py
@@ -0,0 +1,23 @@
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        output = ''
+        for string in strs:
+            output += str(len(string))+'#'+string
+        return output
+        
+
+    def decode(self, s: str) -> List[str]:
+        output = []
+        i = 0
+        
+        while i<len(s):
+            j = i+1
+            
+            while s[j]!='#': j += 1
+                    
+            l = int(s[i:j])
+            string = s[j+1:j+1+l]
+            output.append(string)
+            i = j+1+l
+            
+        return output
\ No newline at end of file
diff --git a/problems/python3/evaluate-reverse-polish-notation.py b/problems/python3/evaluate-reverse-polish-notation.py
new file mode 100644
index 0000000..bbaf62e
--- /dev/null
+++ b/problems/python3/evaluate-reverse-polish-notation.py
@@ -0,0 +1,22 @@
+class Solution:
+    def evalRPN(self, tokens: List[str]) -> int:
+        operators = set(['+', '-', '*', '/'])
+        stack = []
+        
+        for c in tokens:
+            if c in operators:
+                n2 = stack.pop()
+                n1 = stack.pop()
+                
+                if c=='+':
+                    stack.append(n1+n2)
+                elif c=='-':
+                    stack.append(n1-n2)
+                elif c=='*':
+                    stack.append(n1*n2)
+                elif c=='/':
+                    stack.append(int(n1/n2))
+            else:
+                stack.append(int(c))
+        
+        return stack.pop()
\ No newline at end of file
diff --git a/problems/python3/find-median-from-data-stream.py b/problems/python3/find-median-from-data-stream.py
new file mode 100644
index 0000000..f83ee40
--- /dev/null
+++ b/problems/python3/find-median-from-data-stream.py
@@ -0,0 +1,32 @@
+class MedianFinder:
+
+    def __init__(self):
+        self.large = [] #store nums larger or equal to the median
+        self.small = [] #store nums samaller to the median
+
+    def addNum(self, num: int) -> None:
+        if not self.large and not self.small:
+            heapq.heappush(self.large, num)
+        elif num>=self.findMedian():
+            heapq.heappush(self.large, num)
+            self.balance()
+        else:
+            heapq.heappush(self.small, -num)
+            self.balance()
+    
+    def balance(self) -> None:
+        #make the length of two heaps as even as posible
+        if len(self.large)>len(self.small)+1:
+            num = heapq.heappop(self.large)
+            heapq.heappush(self.small, -num)
+        
+        if len(self.small)>len(self.large):
+            num = -heapq.heappop(self.small)
+            heapq.heappush(self.large, num)
+    
+
+    def findMedian(self) -> float:
+        if (len(self.large)+len(self.small))%2==0:
+            return (self.large[0]-self.small[0])/2
+        else:
+            return self.large[0]
\ No newline at end of file
diff --git a/problems/python3/find-minimum-in-rotated-sorted-array.py b/problems/python3/find-minimum-in-rotated-sorted-array.py
new file mode 100644
index 0000000..c9af305
--- /dev/null
+++ b/problems/python3/find-minimum-in-rotated-sorted-array.py
@@ -0,0 +1,22 @@
+"""
+Usually the binary search problem, the hard part is to clear all the edge cases.
+What will be the edge case? It will be when the recursive function executed at the deepest level. Usually the list with only one or two element.
+So I will suggest before submit, try out the case like [0,1] or [1,0] to make sure it will not run unstop.
+"""
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        def helper(l, r):
+            nonlocal ans
+            if l>r: return
+            
+            m = l + int((r-l)/2)
+            if nums[l]<=nums[m]:
+                ans = min(ans, nums[l])
+                helper(m+1, r)
+            else:
+                ans = min(ans, nums[m+1])
+                helper(l, m)
+        
+        ans = float('inf')
+        helper(0, len(nums)-1)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/find-the-duplicate-number.py b/problems/python3/find-the-duplicate-number.py
new file mode 100644
index 0000000..41636df
--- /dev/null
+++ b/problems/python3/find-the-duplicate-number.py
@@ -0,0 +1,16 @@
+class Solution:
+    def findDuplicate(self, nums: List[int]) -> int:
+        head = nums[0]
+        slow = head
+        fast = head
+        
+        while True:
+            slow = nums[slow]
+            fast = nums[nums[fast]]
+            if slow==fast: break
+        
+        slow = head
+        while slow!=fast:
+            slow = nums[slow]
+            fast = nums[fast]
+        return slow
\ No newline at end of file
diff --git a/problems/python3/gas-station.py b/problems/python3/gas-station.py
new file mode 100644
index 0000000..017eaa6
--- /dev/null
+++ b/problems/python3/gas-station.py
@@ -0,0 +1,23 @@
+"""
+First thing, you must understand that if sum(gas)>=sum(cost) there must be an answer. Guaranteed.
+If we know there is an answer, we can simply test all the index.
+If the currGas ever drops to below 0, it means that we need to switch a "start".
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution:
+    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
+        if sum(gas)<sum(cost): return -1
+        
+        start = 0
+        currGas = 0
+        
+        for i in range(len(gas)):
+            currGas += gas[i]-cost[i]
+            
+            if currGas<0:
+                currGas = 0
+                start = i+1
+        
+        return start
\ No newline at end of file
diff --git a/problems/python3/generate-parentheses.py b/problems/python3/generate-parentheses.py
new file mode 100644
index 0000000..9b96ef9
--- /dev/null
+++ b/problems/python3/generate-parentheses.py
@@ -0,0 +1,20 @@
+class Solution:
+    def generateParenthesis(self, n: int) -> List[str]:
+        def helper(parentheses, left, right):
+            if len(parentheses)==n*2:
+                ans.append("".join(parentheses))
+                return
+            
+            if left<n:
+                parentheses.append('(')
+                helper(parentheses, left+1, right)
+                parentheses.pop()
+            
+            if left>right:
+                parentheses.append(')')
+                helper(parentheses, left, right+1)
+                parentheses.pop()
+        
+        ans = []
+        helper([], 0, 0)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/graph-valid-tree.py b/problems/python3/graph-valid-tree.py
new file mode 100644
index 0000000..2168e9a
--- /dev/null
+++ b/problems/python3/graph-valid-tree.py
@@ -0,0 +1,33 @@
+class Solution:
+    def validTree(self, N: int, edges: List[List[int]]) -> bool:
+        def union(n1, n2) -> bool:
+            p1 = find(n1)
+            p2 = find(n2)
+            
+            if p1==p2:
+                return False
+            elif p1<p2:
+                parents[p2] = p1
+            else:
+                parents[p1] = p2
+                
+            return True
+            
+        
+        def find(n) -> int:
+            p = parents[n]
+            while p!=parents[p]: p = find(p)
+            parents[n] = p
+            return p
+        
+        parents = [n for n in range(N)]
+
+        for n1, n2 in edges:
+            if not union(n1, n2): return False
+        
+        #check if all node trace back to the same root
+        root = find(0)
+        for n in range(1, N):
+            if root!=find(n): return False
+        
+        return True
\ No newline at end of file
diff --git a/problems/python3/group-anagrams.py b/problems/python3/group-anagrams.py
new file mode 100644
index 0000000..7430f48
--- /dev/null
+++ b/problems/python3/group-anagrams.py
@@ -0,0 +1,23 @@
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        def normalize(string: str) -> str:
+            counter = collections.Counter()
+            ans = ''
+            
+            for c in string:
+                counter[c] += 1
+            
+            for c in 'abcdefghijklmnopqrstuvwxyz':
+                if counter[c]>0:
+                    ans += c+str(counter[c])
+            return ans
+                    
+        group = collections.defaultdict(list)
+        ans = []
+        
+        for string in strs:
+            group[normalize(string)].append(string)
+        
+        for normalizedString in group:
+            ans.append(group[normalizedString])    
+        return ans
\ No newline at end of file
diff --git a/problems/python3/hand-of-straights.py b/problems/python3/hand-of-straights.py
new file mode 100644
index 0000000..f20c32d
--- /dev/null
+++ b/problems/python3/hand-of-straights.py
@@ -0,0 +1,18 @@
+class Solution:
+    def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:
+        if len(hand)%groupSize!=0: return False
+        
+        counter = collections.Counter(hand)
+        h = list(counter.keys())
+        heapq.heapify(h)
+        
+        while h:
+            minNum = h[0]
+            for n in range(minNum, minNum+groupSize):
+                if counter[n]<=0: return False
+                counter[n] -= 1
+                if counter[n]==0:
+                    if h[0]!=n: return False
+                    heapq.heappop(h)
+        
+        return True
\ No newline at end of file
diff --git a/problems/python3/happy-number.py b/problems/python3/happy-number.py
new file mode 100644
index 0000000..7756197
--- /dev/null
+++ b/problems/python3/happy-number.py
@@ -0,0 +1,17 @@
+class Solution:
+    def isHappy(self, n: int) -> bool:
+        def digitSquare(n) -> int:
+            ans = 0
+            while n>0:
+                ans += (n%10)**2
+                n = n//10
+            return ans
+
+        visited = set()
+        visited.add(1)
+
+        while n not in visited:
+            visited.add(n)
+            n = digitSquare(n)
+
+        return n==1
diff --git a/problems/python3/house-robber-ii.py b/problems/python3/house-robber-ii.py
new file mode 100644
index 0000000..1ed9b82
--- /dev/null
+++ b/problems/python3/house-robber-ii.py
@@ -0,0 +1,18 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if len(nums)<=1: return max(nums)
+        
+        N = len(nums)
+        dp = [[0, 0] for _ in range(N)]
+        dp[0][0] = nums[0]
+        
+        for i in range(1, N):
+            dp[i][0] = nums[i]+dp[i-1][1]
+            dp[i][1] = max(dp[i-1])
+        
+        dp2 = [[0, 0] for _ in range(N)]
+        for i in range(1, N):
+            dp2[i][0] = nums[i]+dp2[i-1][1]
+            dp2[i][1] = max(dp2[i-1])
+        
+        return max(dp[-1][1], dp2[-1][0])
\ No newline at end of file
diff --git a/problems/python3/house-robber.py b/problems/python3/house-robber.py
new file mode 100644
index 0000000..fbd86a5
--- /dev/null
+++ b/problems/python3/house-robber.py
@@ -0,0 +1,17 @@
+"""
+Time: O(N)
+Space: O(N), can reduece to O(1).
+
+dp[i][0] := max revenue if house i robbed
+dp[i][1] := max revenue if house i not robbed
+"""
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        N = len(nums)
+        dp = [[0, 0] for _ in range(N)]
+        dp[0][0] = nums[0]
+        
+        for i in range(1, N):
+            dp[i][0] = nums[i]+dp[i-1][1]
+            dp[i][1] = max(dp[i-1])
+        return max(dp[-1])
\ No newline at end of file
diff --git a/problems/python3/implement-trie-prefix-tree.py b/problems/python3/implement-trie-prefix-tree.py
new file mode 100644
index 0000000..1118e97
--- /dev/null
+++ b/problems/python3/implement-trie-prefix-tree.py
@@ -0,0 +1,26 @@
+class Trie:
+
+    def __init__(self):
+        self.root = {}
+
+    def insert(self, word: str) -> None:
+        node = self.root
+        for c in word:
+            if c not in node: node[c] = {}
+            node = node[c]
+        node['.'] = {} #'.' means the end of the word
+        
+        
+    def search(self, word: str) -> bool:
+        node = self.root
+        for c in word:
+            if c not in node: return False
+            node = node[c]
+        return '.' in node
+
+    def startsWith(self, prefix: str) -> bool:
+        node = self.root
+        for c in prefix:
+            if c not in node: return False
+            node = node[c]
+        return True
diff --git a/problems/python3/insert-interval.py b/problems/python3/insert-interval.py
new file mode 100644
index 0000000..667ba04
--- /dev/null
+++ b/problems/python3/insert-interval.py
@@ -0,0 +1,23 @@
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        ans = []
+        i = 0
+        
+        #add intervals before newInterval
+        while i<len(intervals) and intervals[i][1]<newInterval[0]:
+            ans.append(intervals[i])
+            i += 1
+        
+        #add newInterval and merge the overlapped
+        ans.append(newInterval)
+        while i<len(intervals) and intervals[i][0]<=ans[-1][1]:
+            ans[-1][0] = min(ans[-1][0], intervals[i][0])
+            ans[-1][1] = max(ans[-1][1], intervals[i][1])
+            i += 1
+        
+        #add intervals after newInterval
+        while i<len(intervals):
+            ans.append(intervals[i])
+            i += 1
+            
+        return ans
\ No newline at end of file
diff --git a/problems/python3/interleaving-string.py b/problems/python3/interleaving-string.py
new file mode 100644
index 0000000..76f9837
--- /dev/null
+++ b/problems/python3/interleaving-string.py
@@ -0,0 +1,13 @@
+class Solution:
+    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
+        def dfs(i, j):
+            if (i, j) in history: return False
+            if i+j==len(s3): return True
+            if i<len(s1) and s3[i+j]==s1[i] and dfs(i+1, j): return True
+            if j<len(s2) and s3[i+j]==s2[j] and dfs(i, j+1): return True
+            history.add((i, j))
+            return False
+        
+        if len(s1)+len(s2)!=len(s3): return False
+        history = set() #store the failed cases
+        return dfs(0, 0)
\ No newline at end of file
diff --git a/problems/python3/invert-binary-tree.py b/problems/python3/invert-binary-tree.py
new file mode 100755
index 0000000..d69daec
--- /dev/null
+++ b/problems/python3/invert-binary-tree.py
@@ -0,0 +1,36 @@
+"""
+Recursive
+Time: O(N)
+Space: O(LogN)
+"""
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root: return root
+        left = root.left
+        right = root.right
+        root.left = self.invertTree(right)
+        root.right = self.invertTree(left)
+        return root
+
+
+"""
+Iterative
+Time: O(N)
+Space: O(N)
+"""
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if not root: return root
+        q = collections.deque([root])
+        
+        while q:
+            node = q.popleft()
+            left = node.left
+            right = node.right
+            node.right = left
+            node.left = right
+            
+            if node.left: q.append(node.left)
+            if node.right: q.append(node.right)
+        
+        return root
\ No newline at end of file
diff --git a/problems/python3/jump-game-ii.py b/problems/python3/jump-game-ii.py
new file mode 100644
index 0000000..35be09f
--- /dev/null
+++ b/problems/python3/jump-game-ii.py
@@ -0,0 +1,22 @@
+"""
+l and r is the index range we can reach within "steps".
+So while r can not reach the end (`r<len(nums)-1`), we keep update l, r and steps.
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution:
+    def jump(self, nums: List[int]) -> int:
+        l = r = 0
+        steps = 0
+        
+        while r<len(nums)-1:
+            farest = float('-inf')
+            for i in range(l, r+1):
+                farest = max(farest, i+nums[i])
+            
+            l = r+1
+            r = farest
+            steps += 1
+            
+        return steps
\ No newline at end of file
diff --git a/problems/python3/jump-game.py b/problems/python3/jump-game.py
new file mode 100644
index 0000000..cbf2c89
--- /dev/null
+++ b/problems/python3/jump-game.py
@@ -0,0 +1,10 @@
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        maxIndex = 0
+        
+        for i, num in enumerate(nums):
+            if maxIndex<i:
+                return False
+            maxIndex = max(maxIndex, i+num)
+            
+        return True
\ No newline at end of file
diff --git a/problems/python3/k-closest-points-to-origin.py b/problems/python3/k-closest-points-to-origin.py
new file mode 100644
index 0000000..8f08e89
--- /dev/null
+++ b/problems/python3/k-closest-points-to-origin.py
@@ -0,0 +1,10 @@
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        h = []
+        
+        for x, y in points:
+            dis = (x**2+y**2)**0.5
+            heapq.heappush(h, (-dis, x, y))
+            if len(h)>k: heapq.heappop(h)
+        
+        return [(x, y) for dis, x, y in h]
\ No newline at end of file
diff --git a/problems/python3/koko-eating-bananas.py b/problems/python3/koko-eating-bananas.py
new file mode 100644
index 0000000..fe03197
--- /dev/null
+++ b/problems/python3/koko-eating-bananas.py
@@ -0,0 +1,21 @@
+class Solution:
+    def minEatingSpeed(self, piles: List[int], h: int) -> int:
+        def canFinish(k):
+            timeNeeded = 0
+            for pile in piles:
+                timeNeeded += math.ceil(pile/k)
+            return timeNeeded<=h
+        
+        kMin = 1
+        kMax = max(piles)
+        ans = kMax
+        
+        while kMin<=kMax:
+            k = kMin + int((kMax-kMin)/2)
+            if canFinish(k):
+                ans = min(ans, k)
+                kMax = k-1
+            else:
+                kMin = k+1
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python3/kth-largest-element-in-a-stream.py b/problems/python3/kth-largest-element-in-a-stream.py
new file mode 100644
index 0000000..1eb9095
--- /dev/null
+++ b/problems/python3/kth-largest-element-in-a-stream.py
@@ -0,0 +1,14 @@
+class KthLargest:
+
+    def __init__(self, k: int, nums: List[int]):
+        self.k = k
+        self.nums = nums
+        
+        heapq.heapify(self.nums)
+        while len(self.nums)>self.k: heapq.heappop(self.nums)
+        
+
+    def add(self, val: int) -> int:
+        heapq.heappush(self.nums, val)
+        if len(self.nums)>self.k: heapq.heappop(self.nums)
+        return self.nums[0]
\ No newline at end of file
diff --git a/problems/python3/kth-smallest-element-in-a-bst.py b/problems/python3/kth-smallest-element-in-a-bst.py
new file mode 100755
index 0000000..c8a1555
--- /dev/null
+++ b/problems/python3/kth-smallest-element-in-a-bst.py
@@ -0,0 +1,21 @@
+"""
+Time: O(N) for the inorder traversal
+Space: O(LogN) if the tree is balanced.
+"""
+class Solution:
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        count = 0
+        stack = []
+        node = root
+        
+        while stack or node:
+            while node:
+                stack.append(node)
+                node = node.left
+            node = stack.pop()
+            
+            count += 1
+            if count==k: return node.val
+            
+            node = node.right
+        return 0
\ No newline at end of file
diff --git a/problems/python3/largest-rectangle-in-histogram.py b/problems/python3/largest-rectangle-in-histogram.py
new file mode 100644
index 0000000..1cf8508
--- /dev/null
+++ b/problems/python3/largest-rectangle-in-histogram.py
@@ -0,0 +1,21 @@
+"""
+[0] For each height, if the it is lower than the previous one, it means that the previous are not able to extend anymore. So we calculate its area.
+
+[1] If the previous area, is larger than the current one, it means that the current one are able to extand backward.
+"""
+class Solution:
+    def largestRectangleArea(self, heights: List[int]) -> int:
+        maxArea = 0
+        stack = []
+        
+        heights.append(0) #dummy for the ending
+        
+        for i, h in enumerate(heights):
+            start = i
+            while stack and h<stack[-1][1]: #[0]
+                j, h2 = stack.pop()
+                maxArea = max(maxArea, h2*(i-j))
+                start = j
+            stack.append((start, h)) #[1]
+        
+        return maxArea
\ No newline at end of file
diff --git a/problems/python3/last-stone-weight.py b/problems/python3/last-stone-weight.py
new file mode 100644
index 0000000..9b30665
--- /dev/null
+++ b/problems/python3/last-stone-weight.py
@@ -0,0 +1,12 @@
+class Solution:
+    def lastStoneWeight(self, stones: List[int]) -> int:
+        stones = [-stone for stone in stones]
+        heapq.heapify(stones)
+        
+        while len(stones)>=2:
+            w1 = -heapq.heappop(stones)
+            w2 = -heapq.heappop(stones)
+            
+            if w1-w2>0: heapq.heappush(stones, -(w1-w2))
+        
+        return -stones[0] if stones else 0
\ No newline at end of file
diff --git a/problems/python3/letter-combinations-of-a-phone-number.py b/problems/python3/letter-combinations-of-a-phone-number.py
new file mode 100644
index 0000000..582106c
--- /dev/null
+++ b/problems/python3/letter-combinations-of-a-phone-number.py
@@ -0,0 +1,25 @@
+"""
+Time: O(4^N * N), there are around 4^N of combination. Each taking O(N) to form.
+Space: O(N). O(N) for recursion stack. O(N). O(N) for `combination`. O(N+N) ~= O(N).
+"""
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        def helper(i):
+            if i==len(digits):
+                ans.append(''.join(combination))
+                return
+            
+            for c in mapping[digits[i]]:
+                combination.append(c)
+                helper(i+1)
+                combination.pop()
+        
+        mapping = {'2': ('a', 'b', 'c'), '3': ('d', 'e', 'f'),
+            '4': ('g', 'h', 'i'), '5': ('j', 'k', 'l'), '6': ('m', 'n', 'o'),
+            '7': ('p', 'q', 'r', 's'), '8': ('t', 'u', 'v'), '9': ('w', 'x', 'y', 'z')}
+        
+        if not digits: return []
+        ans = []
+        combination = []
+        helper(0)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/linked-list-cycle.py b/problems/python3/linked-list-cycle.py
new file mode 100644
index 0000000..d2e5395
--- /dev/null
+++ b/problems/python3/linked-list-cycle.py
@@ -0,0 +1,16 @@
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        if not head: return False
+        
+        slow = head
+        fast = head
+        
+        while fast:
+            slow = slow.next
+            
+            if not fast.next: return False
+            fast = fast.next.next
+            
+            if slow==fast: return True
+        
+        return False
\ No newline at end of file
diff --git a/problems/python3/longest-common-subsequence.py b/problems/python3/longest-common-subsequence.py
new file mode 100644
index 0000000..5ba3a68
--- /dev/null
+++ b/problems/python3/longest-common-subsequence.py
@@ -0,0 +1,16 @@
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        #dp[i][j] := number of longest Common Subsequence with text2[:i] and text2[:j]
+        
+        N = len(text1)
+        M = len(text2)
+        
+        dp = [[0]*(M+1) for _ in range(N+1)]
+        
+        for i in range(1, N+1):
+            for j in range(1, M+1):
+                if text1[i-1]==text2[j-1]:
+                    dp[i][j] = dp[i-1][j-1]+1
+                else:
+                    dp[i][j] = max(dp[i][j-1], dp[i-1][j])
+        return dp[-1][-1]
\ No newline at end of file
diff --git a/problems/python3/longest-consecutive-sequence.py b/problems/python3/longest-consecutive-sequence.py
new file mode 100644
index 0000000..dec2cfa
--- /dev/null
+++ b/problems/python3/longest-consecutive-sequence.py
@@ -0,0 +1,15 @@
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        numSet = set(nums)
+        ans = 0
+        
+        for num in nums:
+            isStart = num-1 not in numSet
+            if isStart:
+                count = 0
+                temp = num
+                while temp in numSet:
+                    count += 1
+                    temp += 1
+                ans = max(count, ans)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/longest-increasing-path-in-a-matrix.py b/problems/python3/longest-increasing-path-in-a-matrix.py
new file mode 100644
index 0000000..99fed7d
--- /dev/null
+++ b/problems/python3/longest-increasing-path-in-a-matrix.py
@@ -0,0 +1,26 @@
+"""
+Time: O(MN) since the memo at most has MN index.
+Space: O(MN)
+"""
+class Solution:
+    def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
+        def dfs(i0, j0):
+            if (i0, j0) in memo: return memo[(i0, j0)]
+            ans = 1
+            
+            for i, j in ((i0+1, j0), (i0-1, j0), (i0, j0+1),(i0, j0-1)):
+                if i<0 or i>=N or j<0 or j>=M: continue
+                if matrix[i][j]<=matrix[i0][j0]: continue
+                ans = max(ans, 1+dfs(i, j))
+            
+            memo[(i0, j0)] = ans
+            return ans
+            
+        N = len(matrix)
+        M = len(matrix[0])
+        memo = {}
+        ans = 0
+        for i in range(N):
+            for j in range(M):
+                ans = max(ans, dfs(i, j))
+        return ans
\ No newline at end of file
diff --git a/problems/python3/longest-palindromic-substring.py b/problems/python3/longest-palindromic-substring.py
new file mode 100644
index 0000000..9edb477
--- /dev/null
+++ b/problems/python3/longest-palindromic-substring.py
@@ -0,0 +1,45 @@
+"""
+Time: O(N^2)
+Space: O(N^2)
+
+DP, TLE
+"""
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        ans = s[0]
+        N = len(s)
+        dp = [[False]*N for _ in range(N)]
+        
+        for i in range(N): dp[i][i] = True
+        
+        for l in range(2, N+1):
+            for i in range(N):
+                j = i+l-1
+                if j>=N: continue
+                dp[i][j] = s[i]==s[j] and (dp[i+1][j-1] or j-1<i+1)
+                if dp[i][j]: ans = s[i:j+1]
+        return ans
+
+
+"""
+Time: O(N^2)
+Space: O(1)
+"""
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        N = len(s)
+        ans = s[0]
+        
+        for i in range(N):
+            l, r = i, i
+            while l>=0 and r<N and s[l]==s[r]:
+                if r-l+1>len(ans): ans = s[l:r+1]
+                l -= 1
+                r += 1
+            
+            l, r = i, i+1
+            while l>=0 and r<N and s[l]==s[r]:
+                if r-l+1>len(ans): ans = s[l:r+1]
+                l -= 1
+                r += 1
+        return ans
\ No newline at end of file
diff --git a/problems/python3/longest-repeating-character-replacement.py b/problems/python3/longest-repeating-character-replacement.py
new file mode 100644
index 0000000..714d8f1
--- /dev/null
+++ b/problems/python3/longest-repeating-character-replacement.py
@@ -0,0 +1,13 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        counter = collections.Counter()
+        l = 0
+        ans = 0
+        
+        for r in range(len(s)):
+            counter[s[r]] += 1
+            while (r-l+1)-max(counter.values()) > k:
+                counter[s[l]] -= 1
+                l += 1
+            ans = max(ans, r-l+1)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/longest-substring-without-repeating-char.py b/problems/python3/longest-substring-without-repeating-char.py
new file mode 100644
index 0000000..9902bb5
--- /dev/null
+++ b/problems/python3/longest-substring-without-repeating-char.py
@@ -0,0 +1,14 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        ans = 0
+        l = 0
+        seen = set()
+        
+        for r in range(len(s)):
+            while s[r] in seen:
+                seen.remove(s[l])
+                l += 1
+            seen.add(s[r])
+            ans = max(ans, r-l+1)
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python3/lowest-common-ancestor-of-a-binary-search-tree.py b/problems/python3/lowest-common-ancestor-of-a-binary-search-tree.py
new file mode 100755
index 0000000..12e1743
--- /dev/null
+++ b/problems/python3/lowest-common-ancestor-of-a-binary-search-tree.py
@@ -0,0 +1,28 @@
+"""
+Recursive
+Time: O(LogN) if the tree is balanced.
+Space: O(LogN) for the recursion stack.
+"""
+class Solution:
+    def lowestCommonAncestor(self, node: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if q.val<=node.val<=p.val or p.val<=node.val<=q.val:
+            return node
+        elif q.val<node.val and p.val<node.val:
+            return self.lowestCommonAncestor(node.left, p, q)
+        elif node.val<q.val and node.val<p.val:
+            return self.lowestCommonAncestor(node.right, p, q)
+
+
+"""
+Iterative
+Time: O(LogN) if the tree is balanced.
+Space: O(1).
+"""
+class Solution:
+    def lowestCommonAncestor(self, node: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        while not (q.val<=node.val<=p.val or p.val<=node.val<=q.val):
+            if q.val<node.val and p.val<node.val:
+                node = node.left
+            elif node.val<q.val and node.val<p.val:
+                node = node.right
+        return node
\ No newline at end of file
diff --git a/problems/python3/lru-cache.py b/problems/python3/lru-cache.py
new file mode 100644
index 0000000..7cb1822
--- /dev/null
+++ b/problems/python3/lru-cache.py
@@ -0,0 +1,47 @@
+class Node:
+    def __init__(self, key: int, val: int):
+        self.key = key
+        self.val = val
+        self.next = None
+        self.prev = None
+
+class LRUCache:
+    
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.dic = {} #[0]
+        self.head = Node(0, 0) #[3]
+        self.tail = Node(0, 0) #[3]
+        self.head.next = self.tail
+        self.tail.prev = self.head
+        
+    def remove(self, node):
+        node.prev.next = node.next
+        node.next.prev = node.prev
+    
+    def promote(self, node): #[1]
+        #set the node next to head
+        temp = self.head.next
+        node.next = temp
+        temp.prev = node
+        self.head.next = node
+        node.prev = self.head
+
+    def get(self, key: int) -> int:
+        if key in self.dic:
+            node = self.dic[key]
+            self.remove(node)
+            self.promote(node)
+            return node.val
+        return -1
+            
+    def put(self, key: int, value: int) -> None:
+        if key in self.dic:
+            self.remove(self.dic[key])
+        node = Node(key, value)
+        self.promote(node)
+        self.dic[key] = node
+        
+        if len(self.dic)>self.capacity: #[2]
+            del self.dic[self.tail.prev.key]
+            self.remove(self.tail.prev)
diff --git a/problems/python3/max-area-of-island.py b/problems/python3/max-area-of-island.py
new file mode 100644
index 0000000..fd55a94
--- /dev/null
+++ b/problems/python3/max-area-of-island.py
@@ -0,0 +1,23 @@
+class Solution:
+    def maxAreaOfIsland(self, grid: List[List[int]]) -> int:
+        def dfs(i, j) -> int:
+            if i<0 or j<0 or i>=MAX_ROW or j>=MAX_COL: return 0
+            if grid[i][j]==0 or grid[i][j]==2: return 0
+            
+            grid[i][j] = 2 #mark as visited
+            
+            area = 1
+            area += dfs(i+1, j)
+            area += dfs(i-1, j)
+            area += dfs(i, j+1)
+            area += dfs(i, j-1)
+            return area
+            
+        ans = 0
+        MAX_ROW = len(grid)
+        MAX_COL = len(grid[0])
+        
+        for i in range(MAX_ROW):
+            for j in range(MAX_COL):
+                ans = max(ans, dfs(i, j))
+        return ans
\ No newline at end of file
diff --git a/problems/python3/maximum-depth-of-binary-tree.py b/problems/python3/maximum-depth-of-binary-tree.py
new file mode 100755
index 0000000..3146dcf
--- /dev/null
+++ b/problems/python3/maximum-depth-of-binary-tree.py
@@ -0,0 +1,8 @@
+"""
+Time: O(N)
+Space:O(LogN), for recursion stack space.
+"""
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root: return 0
+        return 1+max(self.maxDepth(root.left), self.maxDepth(root.right))
\ No newline at end of file
diff --git a/problems/python3/maximum-product-subarray.py b/problems/python3/maximum-product-subarray.py
new file mode 100644
index 0000000..243bf41
--- /dev/null
+++ b/problems/python3/maximum-product-subarray.py
@@ -0,0 +1,25 @@
+"""
+Time: O(N)
+Space: O(N), can be reduce to O(1)
+
+dp[i][0] := The max product from subarray that end with nums[i]
+dp[i][1] := The min product from subarray that end with nums[i]
+"""
+class Solution:
+    def maxProduct(self, nums: List[int]) -> int:
+        N = len(nums)
+        dp = [[1, 1] for _ in range(N+1)]
+        ans = float('-inf')
+        
+        for i in range(1, N+1):
+            dp[i][0] = dp[i][1] = nums[i-1]
+            
+            if nums[i-1]>0:
+                dp[i][0] = max(dp[i][0], nums[i-1]*dp[i-1][0])
+                dp[i][1] = min(dp[i][1], nums[i-1]*dp[i-1][1])
+            else:
+                dp[i][0] = max(dp[i][0], nums[i-1]*dp[i-1][1])
+                dp[i][1] = min(dp[i][1], nums[i-1]*dp[i-1][0])
+            ans = max(ans, dp[i][0])
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python3/maximum-subarray.py b/problems/python3/maximum-subarray.py
new file mode 100644
index 0000000..6f749fa
--- /dev/null
+++ b/problems/python3/maximum-subarray.py
@@ -0,0 +1,17 @@
+"""
+Time: O(N)
+Space: O(1)
+
+Calculate the prefix sum. Whenever the prefix is negative, we ignore all the value before.
+Update the ans along the way.
+"""
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        ans = float('-inf')
+        currSum = 0
+        
+        for num in nums:
+            if currSum<0: currSum = 0
+            currSum += num
+            ans = max(ans, currSum)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/median-of-two-sorted-arrays.py b/problems/python3/median-of-two-sorted-arrays.py
new file mode 100644
index 0000000..0fa31da
--- /dev/null
+++ b/problems/python3/median-of-two-sorted-arrays.py
@@ -0,0 +1,40 @@
+"""
+Try to find a i on array A and corespoding j on array B.
+
+Aleft = A[i]
+Aright = A[i+1]
+Bleft = B[j]
+Bright = B[j+1]
+
+Such that Aleft<=Bright and Bleft<=Aright
+
+This means that A[:i+1] and B[:j+1] holds all the elements that is less than the median.
+Aright A[i+1:] and B[j+1:] holds all the elements that is larger or equal to the median.
+"""
+class Solution:
+    def findMedianSortedArrays(self, A: List[int], B: List[int]) -> float:
+        if len(A)>len(B): A, B = B, A
+        
+        total = len(A)+len(B)
+        half = total//2
+        l = 0
+        r = len(A)-1
+        
+        while True:
+            i = l + (r-l)//2
+            j = half-(i+1)-1
+            
+            Aleft = A[i] if i>=0 else float('-inf')
+            Aright = A[i+1] if i+1<len(A) else float('inf')
+            Bleft = B[j] if j>=0 else float('-inf')
+            Bright = B[j+1] if j+1<len(B) else float('inf')
+            
+            if Aleft<=Bright and Bleft<=Aright:
+                if total%2==0:
+                    return (max(Aleft, Bleft)+min(Aright, Bright))/2
+                else:
+                    return min(Aright, Bright)
+            elif Aleft>Bright:
+                r = i-1
+            else:
+                l = i+1
\ No newline at end of file
diff --git a/problems/python3/meeting-rooms-ii.py b/problems/python3/meeting-rooms-ii.py
new file mode 100644
index 0000000..1eb4eb4
--- /dev/null
+++ b/problems/python3/meeting-rooms-ii.py
@@ -0,0 +1,12 @@
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
+        intervals.sort()
+        h = []
+        ans = 0
+        
+        for s, e in intervals:
+            while h and s>=h[0][0]:
+                heapq.heappop(h)
+            heapq.heappush(h, (e, s))
+            ans = max(ans, len(h))
+        return ans
\ No newline at end of file
diff --git a/problems/python3/meeting-rooms.py b/problems/python3/meeting-rooms.py
new file mode 100644
index 0000000..60cf429
--- /dev/null
+++ b/problems/python3/meeting-rooms.py
@@ -0,0 +1,10 @@
+class Solution:
+    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
+        intervals.sort()
+        lastEnd = float('-inf')
+        for s, e in intervals:
+            if lastEnd>s:
+                return False
+            else:
+                lastEnd = e
+        return True
\ No newline at end of file
diff --git a/problems/python3/merge-intervals.py b/problems/python3/merge-intervals.py
new file mode 100644
index 0000000..c8a4678
--- /dev/null
+++ b/problems/python3/merge-intervals.py
@@ -0,0 +1,17 @@
+"""
+Time: O(NLogN) for sorting
+Space: O(1) excluding the output.
+"""
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        ans = []
+        intervals.sort()
+        
+        for s, e in intervals:
+            if not ans:
+                ans.append([s, e])
+            elif ans[-1][1]>=s:
+                ans[-1][1] = max(ans[-1][1], e)
+            else:
+                ans.append([s, e])
+        return ans
\ No newline at end of file
diff --git a/problems/python3/merge-triplets-to-form-target-triplet.py b/problems/python3/merge-triplets-to-form-target-triplet.py
new file mode 100644
index 0000000..4708e4f
--- /dev/null
+++ b/problems/python3/merge-triplets-to-form-target-triplet.py
@@ -0,0 +1,15 @@
+"""
+If any element in the triplets is larger than the element in target, it cannot be used.
+Check if we have all 3 index found the same value.
+"""
+class Solution:
+    def mergeTriplets(self, triplets: List[List[int]], target: List[int]) -> bool:
+        okIndex = set()
+        
+        for a, b, c in triplets:
+            if a>target[0] or b>target[1] or c>target[2]: continue
+            if a==target[0]: okIndex.add(0)
+            if b==target[1]: okIndex.add(1)
+            if c==target[2]: okIndex.add(2)
+        
+        return len(okIndex)==3
\ No newline at end of file
diff --git a/problems/python3/merge-two-sorted-lists.py b/problems/python3/merge-two-sorted-lists.py
new file mode 100644
index 0000000..2b31352
--- /dev/null
+++ b/problems/python3/merge-two-sorted-lists.py
@@ -0,0 +1,15 @@
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        head = ListNode() #dummy
+        node = head
+        while list1 and list2:
+            if list1.val<list2.val:
+                node.next = list1
+                list1 = list1.next
+            else:
+                node.next = list2
+                list2 = list2.next
+            node = node.next
+        
+        node.next = list1 or list2
+        return head.next
\ No newline at end of file
diff --git a/problems/python3/min-cost-climbing-stairs.py b/problems/python3/min-cost-climbing-stairs.py
new file mode 100644
index 0000000..c59c446
--- /dev/null
+++ b/problems/python3/min-cost-climbing-stairs.py
@@ -0,0 +1,16 @@
+"""
+Time: O(N)
+Space: O(N), can further reduce to using only 2 variables -> O(1).
+
+dp[i] := the cost to get to index i.
+"""
+class Solution:
+    def minCostClimbingStairs(self, cost: List[int]) -> int:
+        N = len(cost)
+        dp = [float('inf')]*(N+1)
+        dp[0] = 0
+        dp[1] = 0
+        
+        for i in range(2, len(dp)):
+            dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
+        return dp[-1]
\ No newline at end of file
diff --git a/problems/python3/min-cost-to-connect-all-points.py b/problems/python3/min-cost-to-connect-all-points.py
new file mode 100644
index 0000000..4cd6ada
--- /dev/null
+++ b/problems/python3/min-cost-to-connect-all-points.py
@@ -0,0 +1,28 @@
+class Solution:
+    def minCostConnectPoints(self, points: List[List[int]]) -> int:
+        ans = 0
+        visited = set()
+        adj = collections.defaultdict(list)
+        N = len(points)
+        
+        #build adjacency list
+        for i in range(N):
+            x0, y0 = points[i]
+            for j in range(i+1, N):
+                x1, y1 = points[j]
+                dis = abs(x0-x1)+abs(y0-y1)
+                adj[(x0, y0)].append((dis, x1, y1))
+                adj[(x1, y1)].append((dis, x0, y0))
+        
+        h = [(0, points[0][0], points[0][1])] #min heap
+        while len(visited)<N:
+            dis, x, y = heapq.heappop(h)
+            
+            if (x, y) in visited: continue
+            visited.add((x, y))
+            ans += dis
+            
+            for dis1, x1, y1 in adj[(x, y)]:
+                if (x1, y1) in visited: continue
+                heapq.heappush(h, (dis1, x1, y1))
+        return ans
\ No newline at end of file
diff --git a/problems/python3/min-stack.py b/problems/python3/min-stack.py
new file mode 100644
index 0000000..8fe03de
--- /dev/null
+++ b/problems/python3/min-stack.py
@@ -0,0 +1,23 @@
+#"stack" is just a normal stack.
+#"minStack" stores the min of the stack element in the same position.
+#i.e. At the time stack[x] put in to the stack. minStack[x] is the min.
+
+class MinStack:
+
+    def __init__(self):
+        self.stack = []
+        self.minStack = []
+
+    def push(self, val: int) -> None:
+        self.stack.append(val)
+        self.minStack.append(val if (not self.minStack or val<self.minStack[-1]) else self.minStack[-1])
+
+    def pop(self) -> None:
+        self.minStack.pop()
+        return self.stack.pop()
+        
+    def top(self) -> int:
+        return self.stack[-1]
+        
+    def getMin(self) -> int:
+        return self.minStack[-1]
\ No newline at end of file
diff --git a/problems/python3/minimum-interval-to-include-each-query.py b/problems/python3/minimum-interval-to-include-each-query.py
new file mode 100644
index 0000000..ca43de3
--- /dev/null
+++ b/problems/python3/minimum-interval-to-include-each-query.py
@@ -0,0 +1,23 @@
+class Solution:
+    def minInterval(self, intervals: List[List[int]], queries: List[int]) -> List[int]:
+        ans = [-1]*len(queries)
+        queries = sorted([(query, i) for i, query in enumerate(queries)])
+        intervals.sort()
+        h = []
+        
+        itervalIndex = 0
+        for query, queryIndex in queries:
+            #push all intervals that include 'query' to the min heap
+            while itervalIndex<len(intervals) and intervals[itervalIndex][0]<=query:
+                left = intervals[itervalIndex][0]
+                right = intervals[itervalIndex][1]
+                size = right-left+1
+                heapq.heappush(h, (size, right))
+                itervalIndex += 1
+            
+            #pop all intervals that not includes 'query' out of the min heap
+            while h and h[0][1]<query:
+                heapq.heappop(h)
+                
+            if h: ans[queryIndex] = h[0][0]
+        return ans
\ No newline at end of file
diff --git a/problems/python3/minimum-window-substring.py b/problems/python3/minimum-window-substring.py
new file mode 100644
index 0000000..1a23a82
--- /dev/null
+++ b/problems/python3/minimum-window-substring.py
@@ -0,0 +1,25 @@
+class Solution:
+    def minWindow(self, s: str, t: str) -> str:
+        if len(t)>len(s): return ""
+        
+        ans = ""
+        counter1 = collections.Counter(t)
+        charSet = set(t)
+        counter2 = collections.Counter() #sliding window in string s, index between l and r
+        charSet2 = set(s)
+        matchCount = 0 #count of char in the sliding window that counts are larger than the char count in t.
+        
+        l = 0
+        for r in range(len(s)):
+            counter2[s[r]] += 1
+            
+            if s[r] in charSet and counter1[s[r]]==counter2[s[r]]: matchCount += 1
+                
+            while l<len(s) and (s[l] not in charSet or counter2[s[l]]>counter1[s[l]]):
+                counter2[s[l]] -= 1
+                l += 1
+                
+            if matchCount==len(charSet) and (ans=="" or r-l+1<len(ans)):
+                ans = s[l:r+1]
+                
+        return ans
\ No newline at end of file
diff --git a/problems/python3/missing-number.py b/problems/python3/missing-number.py
new file mode 100644
index 0000000..f0531f6
--- /dev/null
+++ b/problems/python3/missing-number.py
@@ -0,0 +1,12 @@
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+        N = len(nums)
+        ans = 0
+        
+        for n in range(N+1):
+            ans ^= n
+        
+        for n in nums:
+            ans ^= n
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python3/multiply-strings.py b/problems/python3/multiply-strings.py
new file mode 100644
index 0000000..be9f675
--- /dev/null
+++ b/problems/python3/multiply-strings.py
@@ -0,0 +1,22 @@
+class Solution:
+    def multiply(self, num1: str, num2: str) -> str:
+        if num1=='0' or num2=='0': return '0'
+        M, N = len(num1), len(num2)
+        temp = [0]*(M+N+1)
+
+        num1, num2 = num1[::-1], num2[::-1]
+        for i in range(M):
+            for j in range(N):
+                digits = int(num1[i])*int(num2[j])
+                temp[i+j] += digits
+                temp[i+j+1] += temp[i+j]//10
+                temp[i+j] = temp[i+j]%10
+        
+        ans = ''
+        temp = temp[::-1]
+        isLeadingZero = True
+        for d in temp:
+            if d!=0 or not isLeadingZero:
+                isLeadingZero = False
+                ans += str(d)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/n-queens.py b/problems/python3/n-queens.py
new file mode 100644
index 0000000..2ab7335
--- /dev/null
+++ b/problems/python3/n-queens.py
@@ -0,0 +1,45 @@
+class Solution:
+    def solveNQueens(self, n: int) -> List[List[str]]:
+        def helper(row: int):
+            if row==n:
+                ans.append(convertFormat(queenCols))
+                return
+            
+            for col in range(n):
+                posDiag = row+col
+                negDiag = row-col
+                
+                if col in colUsed or posDiag in posDiagUsed or negDiag in negDiagUsed: continue
+                
+                queenCols.append(col)
+                colUsed.add(col)
+                posDiagUsed.add(posDiag)
+                negDiagUsed.add(negDiag)
+                
+                helper(row+1)
+                
+                queenCols.pop()
+                colUsed.remove(col)
+                posDiagUsed.remove(posDiag)
+                negDiagUsed.remove(negDiag)
+        
+        def convertFormat(queenCols: List[int]) -> List[str]:
+            output = []
+            for col in queenCols:
+                row = ''
+                for i in range(n):
+                    if i==col:
+                        row += 'Q'
+                    else:
+                        row += '.'
+                output.append(row)
+            return output
+            
+        ans = []
+        queenCols = []
+        colUsed = set()
+        posDiagUsed = set()
+        negDiagUsed = set()
+        
+        helper(0)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/network-delay-time.py b/problems/python3/network-delay-time.py
new file mode 100644
index 0000000..6da8613
--- /dev/null
+++ b/problems/python3/network-delay-time.py
@@ -0,0 +1,23 @@
+class Solution:
+    def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
+        ans = 0
+        adj = collections.defaultdict(list)
+        h = []
+        visited = set()
+        
+        for u, v, w in times:
+            adj[u].append((v, w))
+            
+        heapq.heappush(h, (0, k))
+        while h:
+            timeNeededToGetHere, node = heapq.heappop(h)
+            
+            if node in visited: continue
+            visited.add(node)
+            ans = max(ans, timeNeededToGetHere)
+            
+            for nei, time in adj[node]:
+                if nei in visited: continue
+                heapq.heappush(h, (time+timeNeededToGetHere, nei))
+        
+        return ans if len(visited)==n else -1
\ No newline at end of file
diff --git a/problems/python3/non-overlapping-intervals.py b/problems/python3/non-overlapping-intervals.py
new file mode 100644
index 0000000..b3b6a0d
--- /dev/null
+++ b/problems/python3/non-overlapping-intervals.py
@@ -0,0 +1,17 @@
+"""
+Time: O(NLogN) for sorting.
+"""
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        intervals.sort()
+        
+        ans = 0
+        prevEnd = intervals[0][1]
+        
+        for s, e in intervals[1:]:
+            if s>=prevEnd:
+                prevEnd = e
+            else:
+                ans += 1
+                prevEnd = min(prevEnd, e)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/number-of-1-bits.py b/problems/python3/number-of-1-bits.py
new file mode 100644
index 0000000..2273859
--- /dev/null
+++ b/problems/python3/number-of-1-bits.py
@@ -0,0 +1,10 @@
+"""
+n = n&(n-1) will turn the right most 1 to 0.
+"""
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        ans = 0
+        while n>0:
+            n = n&(n-1)
+            ans += 1
+        return ans
\ No newline at end of file
diff --git a/problems/python3/number-of-connected-components-in-an-undirected-graph.py b/problems/python3/number-of-connected-components-in-an-undirected-graph.py
new file mode 100644
index 0000000..28571ea
--- /dev/null
+++ b/problems/python3/number-of-connected-components-in-an-undirected-graph.py
@@ -0,0 +1,25 @@
+class Solution:
+    def countComponents(self, N: int, edges: List[List[int]]) -> int:
+        def union(n1, n2):
+            p1 = find(n1)
+            p2 = find(n2)
+            if p1==p2:
+                return
+            elif p1<p2:
+                parents[p2] = p1
+            else:
+                parents[p1] = p2
+            
+        def find(n):
+            p = parents[n]
+            while p!=parents[p]: p = find(p)
+            parents[n] = p
+            return p
+        
+        parents = {n:n for n in range(N)}
+        for n1, n2 in edges: union(n1, n2)
+        
+        groups = set()
+        for n in range(N): groups.add(find(n))
+            
+        return len(groups)
\ No newline at end of file
diff --git a/problems/python3/number-of-islands.py b/problems/python3/number-of-islands.py
new file mode 100644
index 0000000..6cc325e
--- /dev/null
+++ b/problems/python3/number-of-islands.py
@@ -0,0 +1,22 @@
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        def dfs(i, j):
+            if i<0 or j<0 or i>=MAX_ROWS or j>=MAX_COLS: return
+            if grid[i][j]!='1': return
+            
+            grid[i][j] = '2'
+            dfs(i+1, j)
+            dfs(i-1, j)
+            dfs(i, j+1)
+            dfs(i, j-1)
+        
+        count = 0
+        MAX_ROWS = len(grid)
+        MAX_COLS = len(grid[0])
+        
+        for i in range(MAX_ROWS):
+            for j in range(MAX_COLS):
+                if grid[i][j]=='1':
+                    dfs(i, j)
+                    count += 1
+        return count
\ No newline at end of file
diff --git a/problems/python3/pacific-atlantic-water-flow.py b/problems/python3/pacific-atlantic-water-flow.py
new file mode 100644
index 0000000..05032b0
--- /dev/null
+++ b/problems/python3/pacific-atlantic-water-flow.py
@@ -0,0 +1,30 @@
+class Solution:
+    def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:
+        def bfs(q, ocian):
+            while q:
+                i0, j0 = q.popleft()
+                if (i0, j0) in ocian: continue
+                ocian.add((i0, j0))
+                
+                for i, j in ((i0+1, j0), (i0-1, j0), (i0, j0+1), (i0, j0-1)):
+                    if i<0 or j<0 or i>=MAX_ROW or j>=MAX_COL: continue
+                    if heights[i][j]>=heights[i0][j0]: q.append((i, j))
+                    
+        MAX_ROW = len(heights)
+        MAX_COL = len(heights[0])
+        
+        #add the top and left to q1
+        pacific = set()
+        q1 = collections.deque()
+        for j in range(MAX_COL): q1.append((0, j))
+        for i in range(MAX_ROW): q1.append((i, 0))
+            
+        #add botton and right to q2
+        atlantic = set()
+        q2 = collections.deque()
+        for j in range(MAX_COL): q2.append((MAX_ROW-1, j))
+        for i in range(MAX_ROW): q2.append((i, MAX_COL-1))
+            
+        bfs(q1, pacific)
+        bfs(q2, atlantic)
+        return pacific.intersection(atlantic)
\ No newline at end of file
diff --git a/problems/python3/palindrome-partitioning.py b/problems/python3/palindrome-partitioning.py
new file mode 100644
index 0000000..d02ef17
--- /dev/null
+++ b/problems/python3/palindrome-partitioning.py
@@ -0,0 +1,64 @@
+"""
+`helper(i)` finds all the palindrome substring from i to j see if we can get an answer by recursively calling `helper(j+1)`.
+
+Time: O(2^N * N), for a string length S, there will be 2^N combination of substrings. For each substring, it will take O(N) to test if they are all palindrome.
+Space: O(N). `partition` will takes O(N) and recursion stack will also take O(N). O(N + N) ~= O(N)
+"""
+class Solution:
+    def partition(self, s: str) -> List[List[str]]:
+        def helper(i):
+            if i>=len(s):
+                ans.append(partition.copy())
+                return
+            
+            for j in range(i, len(s)):
+                if isPalindrome(i, j):
+                    partition.append(s[i:j+1])
+                    helper(j+1)
+                    partition.pop()
+
+        def isPalindrome(i, j):
+            while i<=j:
+                if s[i]!=s[j]: return False
+                i += 1
+                j -= 1
+            return True
+                
+        ans = []
+        partition = []
+        helper(0)
+        return ans
+
+"""
+If you look closely you can see that we execute `isPalindrome` on many repeated substrings.
+We can optimize this by storing the result in `dp` and reuse it.
+Since all the less difference i and j (shorter substring s[i:j+1]) will be process first in the `isPalindrome`.
+When checking if s[i:j+1] is a palindrome or not, we can simply check the if s[i]==s[j] and the previous result (dp[i+1][j-1])
+
+Time: O(2^N * N), The overall time complexity is the same, but isPalindrome is actually a lot faster.
+Space: O(N^2) for `dp`.
+"""
+class Solution:
+    def partition(self, s: str) -> List[List[str]]:
+        def helper(i):
+            if i>=N:
+                ans.append(partition.copy())
+                return
+            
+            for j in range(i, N):
+                if isPalindrome(i, j):
+                    partition.append(s[i:j+1])
+                    helper(j+1)
+                    partition.pop()
+
+        def isPalindrome(i, j):
+            dp[i][j] = i==j or (j-i==1 and s[i]==s[j]) or (s[i]==s[j] and dp[i+1][j-1]) #len==1 palindrome or len==2 palindrome or len>=3 palindrome
+            return dp[i][j]
+        
+        N = len(s)
+        ans = []
+        partition = []
+        dp = [[False]*N for _ in range(N)]
+
+        helper(0)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/palindromic-substrings.py b/problems/python3/palindromic-substrings.py
new file mode 100644
index 0000000..7ef7e96
--- /dev/null
+++ b/problems/python3/palindromic-substrings.py
@@ -0,0 +1,16 @@
+class Solution:
+    def countSubstrings(self, s: str) -> int:
+        def countPalindrome(l, r) -> int:
+            count = 0
+            while l>=0 and r<N and s[l]==s[r]:
+                count += 1
+                l -= 1
+                r += 1
+            return count
+        
+        N = len(s)
+        ans = 0
+        for i in range(N):
+            ans += countPalindrome(i, i)
+            ans += countPalindrome(i, i+1)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/partition-equal-subset-sum.py b/problems/python3/partition-equal-subset-sum.py
new file mode 100644
index 0000000..ca28510
--- /dev/null
+++ b/problems/python3/partition-equal-subset-sum.py
@@ -0,0 +1,20 @@
+"""
+Time: O(2^N), 2^0 + 2^1 + 2^2 + 2^3 + ... 2^(N-1) == 2^N-1
+Space: O(T), T is the sum of nums
+"""
+class Solution:
+    def canPartition(self, nums: List[int]) -> bool:
+        total = sum(nums)
+        if total%2!=0: return False
+        
+        target = total/2
+        possibleSum = set()
+        possibleSum.add(0)
+        for num in nums:
+            temp = set()
+            for p in possibleSum:
+                if p==target or p+num==target: return True
+                temp.add(p)
+                temp.add(p+num)
+            possibleSum = temp
+        return False
\ No newline at end of file
diff --git a/problems/python3/partition-labels.py b/problems/python3/partition-labels.py
new file mode 100644
index 0000000..0c12d00
--- /dev/null
+++ b/problems/python3/partition-labels.py
@@ -0,0 +1,26 @@
+"""
+Time: O(N)
+Space: O(N)
+
+For each char, store its max index in maxIndex.
+Iterate through the string, update the "currMax" along the way.
+currMax is the place we can partition unless it get updated again.
+If the current index is the currMax, update "ans".
+"""
+class Solution:
+    def partitionLabels(self, s: str) -> List[int]:
+        ans = []
+        maxIndex = {}
+        
+        for i, c in enumerate(s):
+            maxIndex[c] = i
+        
+        currMax = 0
+        processedLength = 0
+        for i, c in enumerate(s):
+            currMax = max(currMax, maxIndex[c])
+            if i==currMax:
+                ans.append(i+1 - processedLength)
+                processedLength += ans[-1]
+
+        return ans
\ No newline at end of file
diff --git a/problems/python3/permutation-in-string.py b/problems/python3/permutation-in-string.py
new file mode 100644
index 0000000..cd22781
--- /dev/null
+++ b/problems/python3/permutation-in-string.py
@@ -0,0 +1,28 @@
+class Solution:
+    def checkInclusion(self, s1: str, s2: str) -> bool:
+        if len(s1)>len(s2): return False
+        
+        counter1 = collections.Counter(s1)
+        counter2 = collections.Counter(s2[:len(s1)])
+        matches = 0
+        for c in 'abcdefghijklmnopqrstuvwxyz':
+            if counter1[c]==counter2[c]: matches += 1
+        if matches==26: return True
+        
+        l = 0
+        for r in range(len(s1), len(s2)):
+            counter2[s2[r]] += 1
+            if counter1[s2[r]]==counter2[s2[r]]:
+                matches += 1
+            elif counter1[s2[r]]+1==counter2[s2[r]]:
+                matches -= 1
+            
+            counter2[s2[l]] -= 1
+            if counter1[s2[l]]==counter2[s2[l]]:
+                matches += 1
+            elif counter1[s2[l]]-1==counter2[s2[l]]:
+                matches -= 1
+            l += 1
+            
+            if matches==26: return True
+        return False
\ No newline at end of file
diff --git a/problems/python3/permutations.py b/problems/python3/permutations.py
new file mode 100644
index 0000000..98d536d
--- /dev/null
+++ b/problems/python3/permutations.py
@@ -0,0 +1,28 @@
+"""
+Time: O(N!), since we call helper() N! times.
+Space: O(N) for recursion stacks.
+
+Whenever we call `helper()`, we pick a num that is not "used" and add it to the `permutation`.
+Recursively call the `helper()` until we filled the `permutation`.
+Resotre `permutation` and `used` and try another `num`.
+"""
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        def helper():
+            if len(permutation)==len(nums):
+                ans.append(permutation.copy())
+                return
+            
+            for num in nums:
+                if num in used: continue
+                used.add(num)
+                permutation.append(num)
+                helper()
+                used.remove(num)
+                permutation.pop()
+        
+        ans = []
+        permutation = []
+        used = set()
+        helper()
+        return ans
\ No newline at end of file
diff --git a/problems/python3/plus-one.py b/problems/python3/plus-one.py
new file mode 100644
index 0000000..8cfedb4
--- /dev/null
+++ b/problems/python3/plus-one.py
@@ -0,0 +1,16 @@
+class Solution:
+    def plusOne(self, digits: List[int]) -> List[int]:
+        i = len(digits)-1
+        needAdditionDigit = True
+
+        while i>=0 and needAdditionDigit:
+            if digits[i]==9:
+                digits[i] = 0
+                i -= 1
+                needAdditionDigit = True
+            else:
+                digits[i] += 1
+                needAdditionDigit = False
+        if needAdditionDigit: digits.insert(0, 1)
+        return digits
+        
\ No newline at end of file
diff --git a/problems/python3/powx-n.py b/problems/python3/powx-n.py
new file mode 100644
index 0000000..2b1b4fc
--- /dev/null
+++ b/problems/python3/powx-n.py
@@ -0,0 +1,14 @@
+class Solution:
+    def myPow(self, x: float, k: int) -> float:
+        if k<0: return 1/self.myPow(x, -k)
+
+        if k==0:
+            return 1
+        elif k==1:
+            return x
+        elif k%2==0:
+            half = self.myPow(x, k//2)
+            return half * half
+        else:
+            half = self.myPow(x, (k-1)//2) 
+            return half * half * x
\ No newline at end of file
diff --git a/problems/python3/product-of-array-except-self.py b/problems/python3/product-of-array-except-self.py
new file mode 100644
index 0000000..2309896
--- /dev/null
+++ b/problems/python3/product-of-array-except-self.py
@@ -0,0 +1,45 @@
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        #left[i] := product of all nums left of nums[i] (not include nums[i])
+        left = [1]
+        temp = 1
+        for num in nums:
+            temp *= num
+            left.append(temp)
+        
+        #right[i] := product of all nums right of nums[i] (not include nums[i])
+        right = []
+        temp = 1
+        for num in reversed(nums):
+            temp *= num
+            right.append(temp)
+        right.reverse()
+        right.append(1)
+        right = right[1:]
+        
+        ans = []
+        for i in range(len(nums)):
+            ans.append(left[i]*right[i])
+        return ans
+
+#In Place
+class Solution:
+    def productExceptSelf(self, nums: List[int]) -> List[int]:
+        N = len(nums)
+        ans = [0]*N
+        
+        #generate "left"
+        ans[0] = 1
+        for i in range(1, N):
+            ans[i] = ans[i-1]*nums[i-1]
+        
+        #generate "right"
+        temp = 1
+        for i in range(N-2, -1, -1):
+            temp *= nums[i+1]
+            ans[i] *= temp
+        
+        return ans
+            
+    
+    
\ No newline at end of file
diff --git a/problems/python3/reconstruct-itinerary.py b/problems/python3/reconstruct-itinerary.py
new file mode 100644
index 0000000..14c928f
--- /dev/null
+++ b/problems/python3/reconstruct-itinerary.py
@@ -0,0 +1,27 @@
+"""
+DFS with backtracking.
+"""
+class Solution:
+    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
+        def dfs(start) -> bool:
+            if len(ans)==len(tickets)+1: return True
+            if start not in adj: return False
+            
+            temp = list(adj[start])
+            for i, arr in enumerate(temp):
+                adj[start].pop(i)
+                ans.append(arr)
+                if dfs(arr): return True
+                adj[start].insert(i, arr)
+                ans.pop()
+            return False
+        
+        ans = ['JFK']
+        adj = collections.defaultdict(list)
+        
+        tickets.sort()
+        for des, arr in tickets:
+            adj[des].append(arr)
+        
+        dfs('JFK')
+        return ans
\ No newline at end of file
diff --git a/problems/python3/redundant-connection.py b/problems/python3/redundant-connection.py
new file mode 100644
index 0000000..47bda2e
--- /dev/null
+++ b/problems/python3/redundant-connection.py
@@ -0,0 +1,32 @@
+class Solution:
+    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
+        def union(n1, n2):
+            p1 = find(n1)
+            p2 = find(n2)
+            
+            if p1==p2:
+                return False #union failed, already united.
+            elif p1<p2:
+                roots[p2] = p1
+            else:
+                roots[p1] = p2
+        
+            return True #union success
+        
+        def find(n):
+            if n not in roots:
+                roots[n] = n
+                return n
+            
+            p = roots[n]
+            while p!=roots[p]:
+                p = find(p)
+            roots[n] = p
+            return p
+        
+        roots = {}
+        
+        for n1, n2 in edges:
+            if not union(n1, n2): return (n1, n2)
+        
+        return 'ERROR'
\ No newline at end of file
diff --git a/problems/python3/regular-expression-matching.py b/problems/python3/regular-expression-matching.py
new file mode 100644
index 0000000..93b44e6
--- /dev/null
+++ b/problems/python3/regular-expression-matching.py
@@ -0,0 +1,24 @@
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        def dfs(i, j):
+            if (i, j) in cache: return cache[(i, j)]
+            if i>=M and j>=N: return True
+            if j>=N: return False
+            
+            match = i<M and (s[i]==p[j] or p[j]=='.')
+            
+            if j+1<N and p[j+1]=='*':
+                cache[(i, j)] = (match and dfs(i+1, j)) or dfs(i, j+2) #(use one or more p[j]) or (use zero p[j])
+                return cache[(i, j)]
+            
+            if match:
+                cache[(i, j)] = dfs(i+1, j+1)
+                return cache[(i, j)]
+            
+            cache[(i, j)] = False
+            return cache[(i, j)]
+        
+        cache = {}
+        M = len(s)
+        N = len(p)
+        return dfs(0, 0)
\ No newline at end of file
diff --git a/problems/python3/remove-nth-node-from-end-of-list.py b/problems/python3/remove-nth-node-from-end-of-list.py
new file mode 100644
index 0000000..b59d7ab
--- /dev/null
+++ b/problems/python3/remove-nth-node-from-end-of-list.py
@@ -0,0 +1,47 @@
+#Two pass.
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        #count the length of the linked list
+        node = head
+        count = 0
+        while node:
+            count += 1
+            node = node.next
+        
+
+        node = head
+        steps = count-n-1
+        
+        #steps==-1 means that we need to remove the first node
+        if steps==-1: return head.next
+        
+        #traverse to the node before the node we wanted to remove
+        while steps>0:
+            node = node.next
+            steps -= 1
+        
+        #remove "node.next"
+        node.next = node.next.next
+        
+        return head
+
+
+#One pass. Fast pointer is ahead of slow pointer by n+1
+#So slow pointer will stop at the node before the node we wanted to remove
+class Solution:
+    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
+        dummy = ListNode()
+        dummy.next = head
+
+        ahead = n+1
+        fast = dummy
+        slow = dummy
+        
+        while fast:
+            fast = fast.next
+            ahead -= 1
+            if ahead<0: slow = slow.next
+        
+        slow.next = slow.next.next
+
+        return dummy.next
\ No newline at end of file
diff --git a/problems/python3/reorder-list.py b/problems/python3/reorder-list.py
new file mode 100644
index 0000000..89c6ba2
--- /dev/null
+++ b/problems/python3/reorder-list.py
@@ -0,0 +1,37 @@
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        #find the middle point
+        slow = head
+        fast = head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+        middle = slow.next
+
+        #reverse the linked list after the middle point
+        middle = self.reverseList(middle)
+
+        #separate the linked list before the middle
+        slow.next = None
+        
+        #merge two linked list
+        node = head
+        while middle and node:
+            nextNode = node.next
+            node.next = middle
+            middle = middle.next
+            node.next.next = nextNode
+            node = nextNode
+        return head
+    
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        pre = None
+        node = head
+        
+        while node:
+            nextNode = node.next
+            node.next = pre
+            if not nextNode: return node
+            pre = node
+            node = nextNode
+        
\ No newline at end of file
diff --git a/problems/python3/reverse-bits.py b/problems/python3/reverse-bits.py
new file mode 100644
index 0000000..dfc5191
--- /dev/null
+++ b/problems/python3/reverse-bits.py
@@ -0,0 +1,7 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        res = 0
+        for i in range(32):
+            bit = (n >> i) & 1
+            res = res | (bit << (31 - i))
+        return res
\ No newline at end of file
diff --git a/problems/python3/reverse-integer.py b/problems/python3/reverse-integer.py
new file mode 100644
index 0000000..76137ab
--- /dev/null
+++ b/problems/python3/reverse-integer.py
@@ -0,0 +1,16 @@
+class Solution:
+    def reverse(self, x: int) -> int:
+        MAX = 2**31-1
+        MIN = -2**31
+        ans = 0
+        
+        while x:
+            digit = int(math.fmod(x, 10))
+            x = int(x/10)
+            
+            if ans>MAX//10 or (ans==MAX//10 and digit>MAX%10): return 0
+            if ans<MIN//10 or (ans==MIN//10 and digit<MIN%10): return 0
+            
+            ans = ans*10 + digit
+            
+        return ans
\ No newline at end of file
diff --git a/problems/python3/reverse-linked-list.py b/problems/python3/reverse-linked-list.py
new file mode 100644
index 0000000..c9c0655
--- /dev/null
+++ b/problems/python3/reverse-linked-list.py
@@ -0,0 +1,21 @@
+#Recursive
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        if not head or not head.next: return head
+        temp = self.reverseList(head.next)
+        head.next.next = head
+        head.next = None
+        return temp
+
+#Iterative
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        pre = None
+        node = head
+        
+        while node:
+            nextNode = node.next
+            node.next = pre
+            if not nextNode: return node
+            pre = node
+            node = nextNode
\ No newline at end of file
diff --git a/problems/python3/rotate-image.py b/problems/python3/rotate-image.py
new file mode 100644
index 0000000..c8a872a
--- /dev/null
+++ b/problems/python3/rotate-image.py
@@ -0,0 +1,16 @@
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        l, r = 0, len(matrix[0])-1
+        
+        while l<r:
+            top = l
+            bottom = r
+            for i in range(r-l):
+                topLeft = matrix[top][l+i]
+                matrix[top][l+i] = matrix[bottom-i][l]
+                matrix[bottom-i][l] = matrix[bottom][r-i]
+                matrix[bottom][r-i] = matrix[top+i][r]
+                matrix[top+i][r] = topLeft
+            l += 1
+            r -= 1
+            #the outer layer is finisthed, going into the inner layer
\ No newline at end of file
diff --git a/problems/python3/rotting-oranges.py b/problems/python3/rotting-oranges.py
new file mode 100644
index 0000000..2e1216a
--- /dev/null
+++ b/problems/python3/rotting-oranges.py
@@ -0,0 +1,35 @@
+class Solution:
+    def orangesRotting(self, grid: List[List[int]]) -> int:
+        time = 0
+        rotten = set()
+        aboutToRot = set()
+        fresh = set()
+        
+        for i in range(len(grid)):
+            for j in range((len(grid[0]))):
+                if grid[i][j]==2:
+                    rotten.add((i, j))
+                elif grid[i][j]==1:
+                    fresh.add((i, j))
+        
+        while rotten:
+            i0, j0 = rotten.pop() #randomly get one
+            grid[i0][j0] = 2
+            
+            for i, j in ((i0+1, j0), (i0-1, j0), (i0, j0+1), (i0, j0-1)):
+                if i<0 or j<0 or i>=len(grid) or j>=len(grid[0]): continue
+                if (i, j) in rotten or (i, j) in aboutToRot: continue
+                if (i, j) in fresh:
+                    fresh.remove((i, j))
+                    aboutToRot.add((i, j))
+            
+            if not rotten and not aboutToRot: break
+            
+            if not rotten:
+                time += 1
+                rotten = aboutToRot
+                aboutToRot = set()
+                
+        if fresh: return -1
+        
+        return time
\ No newline at end of file
diff --git a/problems/python3/same-tree.py b/problems/python3/same-tree.py
new file mode 100755
index 0000000..6687f04
--- /dev/null
+++ b/problems/python3/same-tree.py
@@ -0,0 +1,16 @@
+"""
+Time: O(N)
+Space: O(LogN) if the tree is balanced.
+"""
+class Solution:
+    def isSameTree(self, node1: Optional[TreeNode], node2: Optional[TreeNode]) -> bool:
+        if not node1 and not node2:
+            return True
+
+        if (not node1 and node2) or (node1 and not node2):
+            return False
+
+        if node1.val!=node2.val:
+            return False
+
+        return self.isSameTree(node1.left, node2.left) and self.isSameTree(node1.right, node2.right)
\ No newline at end of file
diff --git a/problems/python3/search-a-2d-matrix.py b/problems/python3/search-a-2d-matrix.py
new file mode 100644
index 0000000..2afe301
--- /dev/null
+++ b/problems/python3/search-a-2d-matrix.py
@@ -0,0 +1,22 @@
+class Solution:
+    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
+        N = len(matrix)
+        M = len(matrix[0])
+        
+        l = 0
+        r = N*M-1
+        
+        while l<=r:
+            m = l + int((r-l)/2)
+            
+            i = int(m/M)
+            j = m%M
+            
+            if matrix[i][j]<target:
+                l = m+1
+            elif matrix[i][j]>target:
+                r = m-1
+            else:
+                return True
+        
+        return False
\ No newline at end of file
diff --git a/problems/python3/serialize-and-deserialize-binary-tree.py b/problems/python3/serialize-and-deserialize-binary-tree.py
new file mode 100644
index 0000000..1b057d0
--- /dev/null
+++ b/problems/python3/serialize-and-deserialize-binary-tree.py
@@ -0,0 +1,22 @@
+class Codec:
+
+    def serialize(self, root):
+        if not root: return '#'
+        return str(root.val)+','+self.serialize(root.left)+','+self.serialize(root.right)
+        
+
+    def deserialize(self, data):
+        def helper():
+            if data[self.i]=='#':
+                self.i += 1
+                return None
+            
+            node = TreeNode(int(data[self.i]))
+            self.i += 1
+            node.left = helper()
+            node.right = helper()
+            return node
+        
+        data = data.split(",")
+        self.i = 0
+        return helper()
\ No newline at end of file
diff --git a/problems/python3/set-matrix-zeroes.py b/problems/python3/set-matrix-zeroes.py
new file mode 100644
index 0000000..dd836e5
--- /dev/null
+++ b/problems/python3/set-matrix-zeroes.py
@@ -0,0 +1,28 @@
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        M = len(matrix)
+        N = len(matrix[0])
+        firstRowZero = False
+        
+        for i in range(M):
+            for j in range(N):
+                if matrix[i][j]==0:
+                    matrix[0][j] = 0                    
+                    if i==0:
+                        firstRowZero = True
+                    else:
+                        matrix[i][0] = 0
+        
+        for i in range(1, M):
+            if matrix[i][0]==0:
+                for j in range(N):
+                    matrix[i][j] = 0
+        
+        for j in range(N):
+            if matrix[0][j]==0:
+                for i in range(M):
+                    matrix[i][j] = 0
+        
+        if firstRowZero:
+            for j in range(N):
+                matrix[0][j] = 0
\ No newline at end of file
diff --git a/problems/python3/single-number.py b/problems/python3/single-number.py
new file mode 100644
index 0000000..daa3268
--- /dev/null
+++ b/problems/python3/single-number.py
@@ -0,0 +1,15 @@
+"""
+^ (XOR)
+The same will be 0
+0^0 = 0
+1^1 = 0
+
+Different will be 1
+1^0 = 1
+0^1 = 1
+"""
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        ans = 0
+        for num in nums: ans ^= num
+        return ans
\ No newline at end of file
diff --git a/problems/python3/sliding-window-maximum.py b/problems/python3/sliding-window-maximum.py
new file mode 100644
index 0000000..a535c16
--- /dev/null
+++ b/problems/python3/sliding-window-maximum.py
@@ -0,0 +1,18 @@
+class Solution:
+    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
+        ans = []
+        q = collections.deque()
+        l = r = 0
+        
+        while r<len(nums):
+            while q and nums[q[-1]]<nums[r]: q.pop()
+            q.append(r)
+            
+            while q and q[0]<l: q.popleft()
+            
+            while r-l+1==k:
+                ans.append(nums[q[0]])
+                l += 1
+            
+            r += 1
+        return ans
\ No newline at end of file
diff --git a/problems/python3/spiral-matrix.py b/problems/python3/spiral-matrix.py
new file mode 100644
index 0000000..ddce35c
--- /dev/null
+++ b/problems/python3/spiral-matrix.py
@@ -0,0 +1,90 @@
+"""
+Original's solution
+Time: O(MN)
+Space: O(1)
+"""
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        ans = []
+        x0 = 0
+        y0 = 0
+        dx = len(matrix[0])-1
+        dy = len(matrix)-1
+        direction = 'right'
+        isFirst = True
+        
+        ans.append(matrix[x0][y0])
+        while True:
+            if direction=='right':
+                for x in range(x0+1, x0+dx+1):
+                    ans.append(matrix[y0][x])
+                x0 += dx
+                direction = 'down'
+                
+                if isFirst:
+                    isFirst = False
+                else:
+                    dx -= 1
+                
+                if dy==0: break
+            
+            elif direction=='left':
+                for x in range(x0-1, x0-dx-1, -1):
+                    ans.append(matrix[y0][x])
+                x0 -= dx
+                direction = 'up'
+                dx -= 1
+                if dy==0: break
+            
+            elif direction=='down':
+                for y in range(y0+1, y0+dy+1):
+                    ans.append(matrix[y][x0])
+                y0 += dy
+                direction = 'left'
+                dy -= 1
+                if dx==0: break
+            
+            elif direction=='up':
+                for y in range(y0-1, y0-dy-1, -1):
+                    ans.append(matrix[y][x0])
+                y0 -= dy
+                direction = 'right'
+                dy -= 1
+                if dx==0: break
+        return ans
+
+
+"""
+Answer from Neetcode, more elegant.
+left, right, top, bottom is the border (index is exclusive on the border.
+In other words, for matrix[i][j]
+i: top<i<bottom
+j: left<j<right
+"""
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        res = []
+        left, right = 0, len(matrix[0])
+        top, bottom = 0, len(matrix)
+
+        while left < right and top < bottom:
+            # get every i in the top row
+            for i in range(left, right):
+                res.append(matrix[top][i])
+            top += 1
+            # get every i in the right col
+            for i in range(top, bottom):
+                res.append(matrix[i][right - 1])
+            right -= 1
+            if not (left < right and top < bottom):
+                break
+            # get every i in the bottom row
+            for i in range(right - 1, left - 1, -1):
+                res.append(matrix[bottom - 1][i])
+            bottom -= 1
+            # get every i in the left col
+            for i in range(bottom - 1, top - 1, -1):
+                res.append(matrix[i][left])
+            left += 1
+
+        return res
\ No newline at end of file
diff --git a/problems/python3/subsets-ii.py b/problems/python3/subsets-ii.py
new file mode 100644
index 0000000..be0b0b7
--- /dev/null
+++ b/problems/python3/subsets-ii.py
@@ -0,0 +1,23 @@
+"""
+Time: O(N * 2^N)
+Space: O(N)
+"""
+class Solution:
+    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
+        def helper(i):
+            if i==len(nums):
+                ans.append(subset.copy())
+                return
+            
+            subset.append(nums[i])
+            helper(i+1)
+            subset.pop()
+            
+            while i+1<len(nums) and nums[i]==nums[i+1]: i += 1
+            helper(i+1)
+            
+        nums.sort()
+        ans = []
+        subset = []
+        helper(0)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/subsets.py b/problems/python3/subsets.py
new file mode 100644
index 0000000..9cfcc00
--- /dev/null
+++ b/problems/python3/subsets.py
@@ -0,0 +1,22 @@
+"""
+Time: O(N * 2^N)
+Space: O(N) for "subset".
+"""
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        def helper(i):
+            if not i<len(nums):
+                ans.append(subset.copy())
+                return
+            
+            subset.append(nums[i])
+            helper(i+1)
+            
+            subset.pop()
+            helper(i+1)
+        
+        ans = []
+        subset = []
+        
+        helper(0)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/substring-with-concatenation-of-all-words.py b/problems/python3/substring-with-concatenation-of-all-words.py
new file mode 100755
index 0000000..164dfa6
--- /dev/null
+++ b/problems/python3/substring-with-concatenation-of-all-words.py
@@ -0,0 +1,46 @@
+"""
+Time: O(W * N/W * W), there will be W time of iteration in the first loop ([0]), N/W of iteration in the second loop ([1]). In each loop, creating substring "word" and "popWord" takes O(W).
+Space: O(MW) for "wordSet".
+"""
+class Solution:
+    def findSubstring(self, s: str, words: List[str]) -> List[int]:
+        N = len(s)
+        M = len(words)
+        W = len(words[0])
+        wordSet = set(words)
+        ans = []
+        counter = collections.Counter(words)
+        
+        for i in range(W): #[0]
+            windowCounter = collections.Counter() #counter for the word in words
+            notInWords = 0 #number of word not in the wordSet
+            theSame = 0 #number of word with the same count with "counter"
+            j = i
+            
+            while j<N: #[1]
+                word = s[j:j+W]
+                if word in wordSet:
+                    windowCounter[word] += 1
+                    if windowCounter[word]==counter[word]:
+                        theSame += 1
+                    elif windowCounter[word]>counter[word]:
+                        theSame -= 1
+                else:
+                    notInWords += 1
+                    
+                popStart = j-M*W
+                if popStart>=0:
+                    popWord = s[popStart:popStart+W]
+                    if popWord in wordSet:
+                        windowCounter[popWord] -= 1
+                        if windowCounter[popWord]==counter[popWord]:
+                            theSame += 1
+                        elif windowCounter[popWord]<counter[popWord]:
+                            theSame -= 1
+                    else:
+                        notInWords -= 1
+                
+                if theSame==len(wordSet) and notInWords==0: ans.append(popStart+W)
+                j += W
+                
+        return ans
\ No newline at end of file
diff --git a/problems/python3/subtree-of-another-tree.py b/problems/python3/subtree-of-another-tree.py
new file mode 100755
index 0000000..7871f8c
--- /dev/null
+++ b/problems/python3/subtree-of-another-tree.py
@@ -0,0 +1,10 @@
+class Solution:
+    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
+        if not root or not subRoot: return root==subRoot
+        if self.isSame(root, subRoot): return True
+        return self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)
+        
+    def isSame(self, p, q):
+        if not p or not q: return p==q
+        if p.val!=q.val: return False
+        return self.isSame(p.left, q.left) and self.isSame(p.right, q.right)
\ No newline at end of file
diff --git a/problems/python3/sum-of-two-integers.py b/problems/python3/sum-of-two-integers.py
new file mode 100644
index 0000000..25f16f9
--- /dev/null
+++ b/problems/python3/sum-of-two-integers.py
@@ -0,0 +1,12 @@
+"""
+Does not work with negative values yet.
+"""
+class Solution:
+    def getSum(self, a: int, b: int) -> int:
+        ans = a^b
+        carry = (a&b)<<1
+        
+        while carry!=0:
+            ans, carry = ans^carry, (ans&carry)<<1
+            
+        return ans
\ No newline at end of file
diff --git a/problems/python3/surrounded-regions.py b/problems/python3/surrounded-regions.py
new file mode 100644
index 0000000..42aa4c0
--- /dev/null
+++ b/problems/python3/surrounded-regions.py
@@ -0,0 +1,34 @@
+"""
+Time: O(N)
+Space: O(N)
+"""
+class Solution:
+    def solve(self, board: List[List[str]]) -> None:
+        def dfs(i0, j0):
+            if i0<0 or j0<0 or i0>=MAX_ROW or j0>=MAX_COL: return
+            if board[i0][j0]!='O': return
+            if (i0, j0) in survived: return
+            
+            survived.add((i0, j0))
+            dfs(i0+1, j0)
+            dfs(i0-1, j0)
+            dfs(i0, j0+1)
+            dfs(i0, j0-1)
+        
+        
+        MAX_ROW = len(board)
+        MAX_COL = len(board[0])
+        survived = set()
+        
+        for i in range(MAX_ROW):
+            dfs(i, 0)
+            dfs(i, MAX_COL-1)
+        
+        for j in range(MAX_COL):
+            dfs(0, j)
+            dfs(MAX_ROW-1, j)
+        
+        for i in range(MAX_ROW):
+            for j in range(MAX_COL):
+                board[i][j] = 'O' if (i, j) in survived else 'X'
+        return board
\ No newline at end of file
diff --git a/problems/python3/swim-in-rising-water.py b/problems/python3/swim-in-rising-water.py
new file mode 100644
index 0000000..dd5dbef
--- /dev/null
+++ b/problems/python3/swim-in-rising-water.py
@@ -0,0 +1,23 @@
+"""
+Time: O(N^2 * LogN^2) = O(N^2 * 2LogN) = O(N^2LogN), N is the number of elements in a row or column.
+Space: O(N^2)
+"""
+class Solution:
+    def swimInWater(self, grid: List[List[int]]) -> int:
+        ROWS = len(grid)
+        COLS = len(grid[0])
+        
+        visited = set()
+        h = [(grid[0][0], 0, 0)]
+        
+        while h:
+            t, r0, c0 = heapq.heappop(h)
+            
+            if (r0, c0) in visited: continue
+            visited.add((r0, c0))
+            if r0==ROWS-1 and c0==COLS-1: return t
+            
+            for r, c in ((r0+1, c0), (r0-1, c0), (r0, c0+1), (r0, c0-1)):
+                if r<0 or c<0 or r>=ROWS or c>=COLS: continue
+                if (r, c) in visited: continue
+                heapq.heappush(h, (max(t, grid[r][c]), r, c))
\ No newline at end of file
diff --git a/problems/python3/target-sum.py b/problems/python3/target-sum.py
new file mode 100644
index 0000000..832fadd
--- /dev/null
+++ b/problems/python3/target-sum.py
@@ -0,0 +1,25 @@
+"""
+Time: O(NS), S is sum(nums), N is len(nums). This is the max possible number of element in "history". Which will be lesser than 2^N.
+Space: O(NS)
+"""
+class Solution:
+    def findTargetSumWays(self, nums: List[int], target: int) -> int:
+        def dfs(i, curr):
+            #cache
+            if (i, curr) in history:
+                return history[(i, curr)]
+            
+            #ending condition
+            if i==len(nums):
+                if curr==target:
+                    history[(i, curr)] = 1
+                else:
+                    history[(i, curr)] = 0
+                return history[(i, curr)]
+            
+            history[(i, curr)] = dfs(i+1, curr+nums[i])+dfs(i+1, curr-nums[i])
+            return history[(i, curr)]
+        
+        ans = 0
+        history = {}
+        return dfs(0, 0)
\ No newline at end of file
diff --git a/problems/python3/task-scheduler.py b/problems/python3/task-scheduler.py
new file mode 100644
index 0000000..ddc4625
--- /dev/null
+++ b/problems/python3/task-scheduler.py
@@ -0,0 +1,23 @@
+class Solution:
+    def leastInterval(self, tasks: List[str], n: int) -> int:
+        q = collections.deque()
+        h = []
+        time = 0
+        
+        counter = collections.Counter(tasks)
+        for task in counter:
+            heapq.heappush(h, (-counter[task], task))
+        
+        while h or q:
+            if q and q[0][0]<=time:
+                _, count, task = q.popleft()
+                heapq.heappush(h, (-count, task))
+            
+            if h:
+                count, task = heapq.heappop(h)
+                count*=-1
+                count -= 1
+                if count>0: q.append((time+n+1, count, task))
+            time += 1
+        
+        return time
\ No newline at end of file
diff --git a/problems/python3/time-based-key-value-store.py b/problems/python3/time-based-key-value-store.py
new file mode 100644
index 0000000..f43facf
--- /dev/null
+++ b/problems/python3/time-based-key-value-store.py
@@ -0,0 +1,28 @@
+class TimeMap:
+
+    def __init__(self):
+        self.data = collections.defaultdict(list)
+
+    def set(self, key: str, value: str, timestamp: int) -> None:
+        self.data[key].append((timestamp, value))
+        
+    def get(self, key: str, timestamp: int) -> str:
+        dataList = self.data[key]
+        l = 0
+        r = len(dataList)-1
+        ans = ''
+        
+        while l<=r:
+            m = l + int((r-l)/2)
+            t = dataList[m][0]
+            
+            if t<timestamp:
+                ans = dataList[m][1]
+                l = m+1
+            elif t>timestamp:
+                r = m-1
+            else:
+                ans = dataList[m][1]
+                break
+        
+        return ans
\ No newline at end of file
diff --git a/problems/python3/top-k-frequent-elements.py b/problems/python3/top-k-frequent-elements.py
new file mode 100644
index 0000000..7d728cb
--- /dev/null
+++ b/problems/python3/top-k-frequent-elements.py
@@ -0,0 +1,53 @@
+#Bucket Sort
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        bucket = collections.defaultdict(list)
+        counter = collections.Counter(nums)
+        ans = []
+        
+        for num in counter:
+            bucket[counter[num]].append(num)
+        
+        tempCount = len(nums)
+        while len(ans)<k:
+            ans.extend(bucket[tempCount])
+            tempCount -= 1
+        
+        return ans
+
+#QuickSelect
+class Solution:
+    def topKFrequent(self, nums: List[int], K: int) -> List[int]:
+        def quickSelect(freqs, s, e, K):
+            i = s
+            t = s
+            j = e
+            pivot = freqs[(s+e)//2][1]
+            
+            while t<=j:
+                if freqs[t][1]<pivot:
+                    freqs[i], freqs[t] = freqs[t], freqs[i]
+                    i += 1
+                    t +=1
+                elif freqs[t][1]>pivot:
+                    freqs[j], freqs[t] = freqs[t], freqs[j]
+                    j -= 1
+                else:
+                    t += 1
+            if e-j>=K:
+                return quickSelect(freqs, j+1, e, K)
+            elif e-(i-1)>=K:
+                return pivot
+            else:
+                return quickSelect(freqs, s, i-1, K-(e-i+1))
+                
+        counts = collections.Counter(nums)
+        freqs = [(num, counts[num]) for num in counts]
+        ans = []
+        
+        KthLargestFreq = quickSelect(freqs, 0, len(freqs)-1, K)
+        
+        for num, freq in freqs:
+            if freq>=KthLargestFreq:
+                ans.append(num)
+        return ans
\ No newline at end of file
diff --git a/problems/python3/trapping-rain-water.py b/problems/python3/trapping-rain-water.py
new file mode 100644
index 0000000..fe01411
--- /dev/null
+++ b/problems/python3/trapping-rain-water.py
@@ -0,0 +1,35 @@
+"""
+The water stored at i is `min(leftMax, rightMax) - height[i]`
+leftMax: max height left of i
+rightMax: max height right of i
+
+To use only constant space.
+We can calculete the leftMax or rightMax and update ans along the way.
+And we always go with the side where leftMax or rightMax is smaller.
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        ans = 0
+        l = 0
+        r = len(height)-1
+        
+        leftMax = float('-inf')
+        rightMax = float('-inf')
+        
+        while l<=r:
+            if leftMax<rightMax:
+                if height[l]>=leftMax:
+                    leftMax = height[l]
+                else:
+                    ans += leftMax-height[l]
+                l += 1
+            else:
+                if height[r]>=rightMax:
+                    rightMax = height[r]
+                else:
+                    ans += rightMax-height[r]
+                r -= 1
+        return ans
\ No newline at end of file
diff --git a/problems/python3/two-sum-ii-input-array-is-sorted.py b/problems/python3/two-sum-ii-input-array-is-sorted.py
new file mode 100644
index 0000000..2890404
--- /dev/null
+++ b/problems/python3/two-sum-ii-input-array-is-sorted.py
@@ -0,0 +1,11 @@
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        i = 0
+        j = len(numbers)-1
+        
+        while numbers[i]+numbers[j] != target:
+            if numbers[i]+numbers[j] > target:
+                j -= 1
+            else:
+                i += 1
+        return (i+1, j+1)
\ No newline at end of file
diff --git a/problems/python3/two-sum.py b/problems/python3/two-sum.py
new file mode 100644
index 0000000..aa90d66
--- /dev/null
+++ b/problems/python3/two-sum.py
@@ -0,0 +1,8 @@
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        #needed: {number required : counter part index}
+        needed = {}
+        for i, num in enumerate(nums):
+            if num in needed:
+                return (needed[num], i)
+            needed[target-num] = i
\ No newline at end of file
diff --git a/problems/python3/unique-paths.py b/problems/python3/unique-paths.py
new file mode 100644
index 0000000..9c7ce40
--- /dev/null
+++ b/problems/python3/unique-paths.py
@@ -0,0 +1,11 @@
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        m = m-1 #number of steps need to move down
+        n = n-1 #number of steps need to move right
+        
+        #the total combination of m and n to sort will be (m+n)!
+        #since all "move down" are consider the same, we need to remove the repeatition of it sorting: m!.
+        #since all "move right" are consider the same, we need to remove the repeatition of it sorting: n!.
+        #(m+n)!/m!n!
+        
+        return math.factorial(m+n)//(math.factorial(m)*math.factorial(n))
\ No newline at end of file
diff --git a/problems/python3/valid-anagram.py b/problems/python3/valid-anagram.py
new file mode 100644
index 0000000..6c37cb0
--- /dev/null
+++ b/problems/python3/valid-anagram.py
@@ -0,0 +1,17 @@
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        counter = collections.Counter()
+        
+        for c in s:
+            counter[c] += 1
+        
+        for c in t:
+            if c not in counter:
+                return False
+            counter[c] -= 1
+        
+        for c in counter:
+            if counter[c]>0:
+                return False
+        
+        return True
\ No newline at end of file
diff --git a/problems/python3/valid-palindrome.py b/problems/python3/valid-palindrome.py
new file mode 100644
index 0000000..0069c83
--- /dev/null
+++ b/problems/python3/valid-palindrome.py
@@ -0,0 +1,15 @@
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        i = 0
+        j = len(s)-1
+        
+        while i<=j:
+            while i<j and not s[i].isalnum(): i += 1
+            while i<j and not s[j].isalnum(): j -= 1
+            
+            if s[i].lower()!=s[j].lower(): return False
+            
+            i += 1
+            j -= 1
+        
+        return True
\ No newline at end of file
diff --git a/problems/python3/valid-parentheses.py b/problems/python3/valid-parentheses.py
new file mode 100644
index 0000000..cb7d047
--- /dev/null
+++ b/problems/python3/valid-parentheses.py
@@ -0,0 +1,17 @@
+class Solution:
+    def isValid(self, s: str) -> bool:
+        mapping = {')': '(', ']': '[', '}':'{'}
+        stack = []
+        
+        for c in s:
+            if c not in mapping:
+                #open parentheses
+                stack.append(c)
+            else:
+                #close parentheses
+                if stack and stack[-1]==mapping[c]:
+                    stack.pop()
+                else:
+                    return False
+        
+        return not stack
\ No newline at end of file
diff --git a/problems/python3/valid-parenthesis-string.py b/problems/python3/valid-parenthesis-string.py
new file mode 100644
index 0000000..52ea446
--- /dev/null
+++ b/problems/python3/valid-parenthesis-string.py
@@ -0,0 +1,23 @@
+class Solution:
+    def checkValidString(self, s: str) -> bool:
+        leftMin = 0
+        leftMax = 0
+        
+        for c in s:
+            if c=='(':
+                leftMin += 1
+                leftMax += 1
+            elif c==')':
+                leftMin -= 1
+                leftMax -= 1
+            else:
+                leftMin -= 1
+                leftMax += 1
+            
+            if leftMax<0:
+                return False
+            
+            if leftMin<0:
+                leftMin = 0
+        
+        return leftMin == 0
\ No newline at end of file
diff --git a/problems/python3/valid-sudoku.py b/problems/python3/valid-sudoku.py
new file mode 100644
index 0000000..b2e6fa7
--- /dev/null
+++ b/problems/python3/valid-sudoku.py
@@ -0,0 +1,37 @@
+class Solution:
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        def rowIsValid(i):
+            used = set()
+            for j in range(N):
+                if board[i][j]=='.': continue
+                if board[i][j] in used: return False
+                used.add(board[i][j])
+            return True
+        
+        def columnIsValid(i):
+            used = set()
+            for j in range(N):
+                if board[j][i]=='.': continue
+                if board[j][i] in used: return False
+                used.add(board[j][i])
+            return True
+        
+        def isBoxValid(i1, i2, j1, j2):
+            used = set()
+            for i in range(i1, i2+1):
+                for j in range(j1, j2+1):
+                    if board[i][j]=='.': continue
+                    if board[i][j] in used: return False
+                    used.add(board[i][j])
+            return True
+                
+        N = 9
+        for i in range(N):
+            if not rowIsValid(i): return False
+            if not columnIsValid(i): return False
+        
+        for i in range(0, N, 3):
+            for j in range(0, N, 3):
+                if not isBoxValid(i, i+2, j, j+2): return False
+        
+        return True
\ No newline at end of file
diff --git a/problems/python3/validate-binary-search-tree.py b/problems/python3/validate-binary-search-tree.py
new file mode 100755
index 0000000..4185bc6
--- /dev/null
+++ b/problems/python3/validate-binary-search-tree.py
@@ -0,0 +1,24 @@
+"""
+The inorder travsersal of a BST is always increasing.
+
+Time: O(N)
+Space: O(N)
+"""
+class Solution:
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        lastVal = float('-inf')
+        stack = []
+        
+        node = root
+        while stack or node:
+            while node:
+                stack.append(node)
+                node = node.left
+            
+            node = stack.pop()
+            
+            if not lastVal<node.val: return False
+            lastVal = node.val
+            
+            node = node.right
+        return True
\ No newline at end of file
diff --git a/problems/python3/walls-and-gates.py b/problems/python3/walls-and-gates.py
new file mode 100644
index 0000000..5f27f9a
--- /dev/null
+++ b/problems/python3/walls-and-gates.py
@@ -0,0 +1,29 @@
+class Solution:
+    def wallsAndGates(self, rooms: List[List[int]]) -> None:
+        def bfs(i0, j0) -> None:
+            q = collections.deque([(i0+1, j0, 1), (i0-1, j0, 1), (i0, j0+1, 1), (i0, j0-1, 1)])
+            visited = set()
+            
+            while q:
+                i, j, dis = q.popleft()
+                
+                if i<0 or j<0 or i>=MAX_ROW or j>=MAX_COL: continue
+                if rooms[i][j]==0 or rooms[i][j]==-1: continue
+                if (i, j, dis) in visited: continue
+                visited.add((i, j, dis))
+                
+                if dis<rooms[i][j]:
+                    rooms[i][j] = dis
+                    q.append((i+1, j, dis+1))
+                    q.append((i-1, j, dis+1))
+                    q.append((i, j+1, dis+1))
+                    q.append((i, j-1, dis+1))
+                
+        MAX_ROW = len(rooms)
+        MAX_COL = len(rooms[0])
+        
+        for i in range(MAX_ROW):
+            for j in range(MAX_COL):
+                if rooms[i][j]==0:
+                    bfs(i, j)
+        return rooms
\ No newline at end of file
diff --git a/problems/python3/word-break.py b/problems/python3/word-break.py
new file mode 100644
index 0000000..8d2c817
--- /dev/null
+++ b/problems/python3/word-break.py
@@ -0,0 +1,23 @@
+"""
+Time: O(N^2 * M). N is the length of the s. M is the number of word in wordDict.
+Note that s[i:i+len(word)]==word takes O(N) time.
+
+Space: O(N) for the recursion memory stack size.
+
+dfs(i) := will return starting at index i, if i to the end the string can be separated.
+"""
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        def dfs(i):
+            if i==len(s): return True
+            if i in history and not history[i]: return False
+            
+            for word in wordDict:
+                if i+len(word)<=len(s) and s[i:i+len(word)]==word:
+                    history[i] = True
+                    if dfs(i+len(word)): return True
+            history[i] = False
+            return False
+        
+        history = {}
+        return dfs(0)
\ No newline at end of file
diff --git a/problems/python3/word-ladder.py b/problems/python3/word-ladder.py
new file mode 100644
index 0000000..453fb4a
--- /dev/null
+++ b/problems/python3/word-ladder.py
@@ -0,0 +1,40 @@
+"""
+Time: O(NxM^2). N is the number of words. M is the length of the word.
+Note that, getPatterns() takes O(M^2) since creating new string will also takes O(M) and for each word we do that O(M) times.
+
+Space: O(NxM^2)
+"""
+class Solution:
+    def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:
+        def getPatterns(word) -> List[str]:
+            patterns = []
+            for i in range(len(word)):
+                pattern = word[:i]+'*'+word[i+1:]
+                patterns.append(pattern)
+            return patterns
+        
+        
+        if endWord not in wordList: return 0
+        wordList.append(beginWord)
+        
+        #build adjacency list
+        nei = collections.defaultdict(list)
+        for word in wordList:
+            for pattern in getPatterns(word):
+                nei[pattern].append(word)
+        
+        #BFS
+        q = collections.deque([(beginWord, 1)])
+        visited = set()
+        while q:
+            word, steps = q.popleft()
+            
+            if word in visited: continue
+            visited.add(word)
+            if word==endWord: return steps
+            
+            for pattern in getPatterns(word):
+                for nextWord in nei[pattern]:
+                    if nextWord in visited: continue
+                    q.append((nextWord, steps+1))
+        return 0
\ No newline at end of file
diff --git a/problems/python3/word-search-ii.py b/problems/python3/word-search-ii.py
new file mode 100644
index 0000000..a285655
--- /dev/null
+++ b/problems/python3/word-search-ii.py
@@ -0,0 +1,54 @@
+"""
+Time: O(M * 4 * 3^(L-1)), M is board elements count, L is the average word length.
+Space: O(N), N is the number of char in the words
+
+This solution will TLE. We need to further "prune" the trie once we reach the leaf node.
+"""
+class TrieNode():
+    def __init__(self):
+        self.children = {}
+        self.isEnd = False
+    def addWord(self, word):
+        curr = self
+        for c in word:
+            if c not in curr.children:
+                curr.children[c] = TrieNode()
+            curr = curr.children[c]
+        curr.isEnd = True
+    
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        def dfs(r, c, node, word):
+            if c<0 or r<0 or c==COLS or r==ROWS: return
+            if board[r][c] not in node.children: return
+            if (r, c) in visited: return
+            
+            visited.add((r, c))
+            node = node.children[board[r][c]]
+            word += board[r][c]
+            if node.isEnd:
+                ans.add(word)
+                node.isEnd = False
+                
+            dfs(r+1, c, node, word)
+            dfs(r-1, c, node, word)
+            dfs(r, c+1, node, word)
+            dfs(r, c-1, node, word)
+            
+            visited.remove((r, c))
+        
+        
+        root = TrieNode()
+        for word in words:
+            root.addWord(word)
+            
+        ROWS = len(board)
+        COLS = len(board[0])
+        
+        visited = set()
+        ans = set()
+        node = root
+        for r in range(ROWS):
+            for c in range(COLS):
+                dfs(r, c, root, '')
+        return ans
\ No newline at end of file
diff --git a/problems/python3/word-search.py b/problems/python3/word-search.py
new file mode 100644
index 0000000..b7ebb09
--- /dev/null
+++ b/problems/python3/word-search.py
@@ -0,0 +1,27 @@
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        def helper(x, i, j):
+            if i<0 or i>=N or j<0 or j>=M: return False
+            if (i, j) in usedWords: return False
+            usedWords.add((i, j))
+            
+            if word[x]==board[i][j]:
+                if x==len(word)-1:
+                    return True
+                else:
+                    if helper(x+1, i+1, j): return True
+                    if helper(x+1, i, j+1): return True
+                    if helper(x+1, i-1, j): return True
+                    if helper(x+1, i, j-1): return True
+                    
+                    
+            usedWords.remove((i, j))
+            return False
+                    
+        usedWords = set()
+        N = len(board)
+        M = len(board[0])
+        for i in range(N):
+            for j in range(M):
+                if helper(0, i, j): return True
+        return False
\ No newline at end of file
diff --git a/problems/vertical-order-traversal-of-a-binary-tree.py b/problems/vertical-order-traversal-of-a-binary-tree.py
deleted file mode 100644
index 9cc1849..0000000
--- a/problems/vertical-order-traversal-of-a-binary-tree.py
+++ /dev/null
@@ -1,28 +0,0 @@
-"""
-The description wants us to report from left to right, top to bottom.
-Thus, we keep add value into `temp` with `x_position` as the key and `(y_position, node.val)` as the value.
-And maintain `min_x`, `max_x` at the same time. So we know how to iterate the `temp`.
-"""
-from collections import defaultdict
-
-class Solution(object):
-    def verticalTraversal(self, root):
-        temp = defaultdict(list)
-        min_x = 0
-        max_x = 0
-
-        stack = []
-        stack.append((root, 0, 0))
-        while stack:
-            node, x, y = stack.pop()
-            temp[x].append((y, node.val)) #append the value of height, so we can sort by height later on
-            min_x = min(min_x, x)
-            max_x = max(max_x, x)
-            if node.left: stack.append((node.left, x-1, y+1))
-            if node.right: stack.append((node.right, x+1, y+1))
-        
-        opt = []
-        for i in range(min_x, max_x+1):
-            opt.append([v for y, v in sorted(temp[i])]) #the temp[i] will be sorted by y_position then sorted by node.val
-        
-        return opt
\ No newline at end of file