From ab00993db54f12ce78a71b3e072637c5ab63b66b Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Wed, 6 Jul 2022 08:07:03 +0200
Subject: [PATCH 01/20] updates

---
 problems/python3/contains-duplicate.py        |  7 +++++
 problems/python3/hand-of-straights.py         | 18 +++++++++++++
 .../merge-triplets-to-form-target-triplet.py  | 15 +++++++++++
 problems/python3/partition-labels.py          | 26 +++++++++++++++++++
 problems/python3/two-sum.py                   |  8 ++++++
 problems/python3/valid-anagram.py             | 17 ++++++++++++
 problems/python3/valid-parenthesis-string.py  | 23 ++++++++++++++++
 7 files changed, 114 insertions(+)
 create mode 100644 problems/python3/contains-duplicate.py
 create mode 100644 problems/python3/hand-of-straights.py
 create mode 100644 problems/python3/merge-triplets-to-form-target-triplet.py
 create mode 100644 problems/python3/partition-labels.py
 create mode 100644 problems/python3/two-sum.py
 create mode 100644 problems/python3/valid-anagram.py
 create mode 100644 problems/python3/valid-parenthesis-string.py

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/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/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/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/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/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-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

From 881c58db2e6c7027d287ac0072444253850c51d7 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Sun, 17 Jul 2022 09:24:20 +0200
Subject: [PATCH 02/20] updates

---
 problems/python3/encode-and-decode-strings.py | 23 ++++++++
 problems/python3/group-anagrams.py            | 23 ++++++++
 .../python3/product-of-array-except-self.py   | 45 ++++++++++++++++
 problems/python3/top-k-frequent-elements.py   | 53 +++++++++++++++++++
 problems/python3/valid-sudoku.py              | 37 +++++++++++++
 5 files changed, 181 insertions(+)
 create mode 100644 problems/python3/encode-and-decode-strings.py
 create mode 100644 problems/python3/group-anagrams.py
 create mode 100644 problems/python3/product-of-array-except-self.py
 create mode 100644 problems/python3/top-k-frequent-elements.py
 create mode 100644 problems/python3/valid-sudoku.py

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/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/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/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/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

From 53d11bc54af366f05292b39cc100faceda21b716 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Sat, 23 Jul 2022 09:02:24 +0200
Subject: [PATCH 03/20] updates

---
 .../best-time-to-buy-and-sell-stock.py        | 10 +++++++
 .../python3/longest-consecutive-sequence.py   | 15 ++++++++++
 ...longest-repeating-character-replacement.py | 13 +++++++++
 ...ongest-substring-without-repeating-char.py | 14 ++++++++++
 problems/python3/permutation-in-string.py     | 28 +++++++++++++++++++
 5 files changed, 80 insertions(+)
 create mode 100644 problems/python3/best-time-to-buy-and-sell-stock.py
 create mode 100644 problems/python3/longest-consecutive-sequence.py
 create mode 100644 problems/python3/longest-repeating-character-replacement.py
 create mode 100644 problems/python3/longest-substring-without-repeating-char.py
 create mode 100644 problems/python3/permutation-in-string.py

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/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-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/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

From b68839f9141a93ad4e002480b308651ab4c35565 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Mon, 1 Aug 2022 08:06:03 +0200
Subject: [PATCH 04/20] update

---
 problems/python3/minimum-window-substring.py | 25 ++++++++++++++++++++
 problems/python3/sliding-window-maximum.py   | 18 ++++++++++++++
 problems/python3/valid-parentheses.py        | 17 +++++++++++++
 3 files changed, 60 insertions(+)
 create mode 100644 problems/python3/minimum-window-substring.py
 create mode 100644 problems/python3/sliding-window-maximum.py
 create mode 100644 problems/python3/valid-parentheses.py

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/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/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

From 612e17e73b2f8f3df6158cfd68f837f7a942eed3 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Tue, 9 Aug 2022 07:17:56 +0200
Subject: [PATCH 05/20] update

---
 problems/python3/car-fleet.py                 | 16 +++++++++++++
 problems/python3/daily-temperatures.py        | 12 ++++++++++
 .../evaluate-reverse-polish-notation.py       | 22 ++++++++++++++++++
 problems/python3/generate-parentheses.py      | 20 ++++++++++++++++
 problems/python3/min-stack.py                 | 23 +++++++++++++++++++
 5 files changed, 93 insertions(+)
 create mode 100644 problems/python3/car-fleet.py
 create mode 100644 problems/python3/daily-temperatures.py
 create mode 100644 problems/python3/evaluate-reverse-polish-notation.py
 create mode 100644 problems/python3/generate-parentheses.py
 create mode 100644 problems/python3/min-stack.py

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/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/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/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/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

From 102969667a38c53844cfa5b2b94353e4ad547d4e Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Sun, 14 Aug 2022 14:52:03 +0200
Subject: [PATCH 06/20] Updates

---
 .../python3/copy-list-with-random-pointer.py  | 34 ++++++++++++++
 .../python3/largest-rectangle-in-histogram.py | 21 +++++++++
 problems/python3/merge-two-sorted-lists.py    | 15 ++++++
 .../remove-nth-node-from-end-of-list.py       | 47 +++++++++++++++++++
 problems/python3/reorder-list.py              | 37 +++++++++++++++
 problems/python3/reverse-linked-list.py       | 21 +++++++++
 6 files changed, 175 insertions(+)
 create mode 100644 problems/python3/copy-list-with-random-pointer.py
 create mode 100644 problems/python3/largest-rectangle-in-histogram.py
 create mode 100644 problems/python3/merge-two-sorted-lists.py
 create mode 100644 problems/python3/remove-nth-node-from-end-of-list.py
 create mode 100644 problems/python3/reorder-list.py
 create mode 100644 problems/python3/reverse-linked-list.py

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/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/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/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-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

From 543e1f893e54b6bb47139db24531ea84ddd92534 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Sat, 20 Aug 2022 09:32:32 +0200
Subject: [PATCH 07/20] updates

---
 problems/python3/add-two-numbers.py           | 19 ++++++++
 problems/python3/find-the-duplicate-number.py | 16 +++++++
 .../kth-largest-element-in-a-stream.py        | 14 ++++++
 problems/python3/last-stone-weight.py         | 12 +++++
 problems/python3/linked-list-cycle.py         | 16 +++++++
 problems/python3/lru-cache.py                 | 47 +++++++++++++++++++
 6 files changed, 124 insertions(+)
 create mode 100644 problems/python3/add-two-numbers.py
 create mode 100644 problems/python3/find-the-duplicate-number.py
 create mode 100644 problems/python3/kth-largest-element-in-a-stream.py
 create mode 100644 problems/python3/last-stone-weight.py
 create mode 100644 problems/python3/linked-list-cycle.py
 create mode 100644 problems/python3/lru-cache.py

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/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/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/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/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/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)

From 758ba68d95d77c4fe7e73a3caec7f79331c73fd0 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Thu, 25 Aug 2022 08:36:37 +0200
Subject: [PATCH 08/20] Updates

---
 problems/python3/design-twitter.py            | 49 +++++++++++++++++++
 .../python3/find-median-from-data-stream.py   | 32 ++++++++++++
 .../python3/k-closest-points-to-origin.py     | 10 ++++
 problems/python3/task-scheduler.py            | 23 +++++++++
 4 files changed, 114 insertions(+)
 create mode 100644 problems/python3/design-twitter.py
 create mode 100644 problems/python3/find-median-from-data-stream.py
 create mode 100644 problems/python3/k-closest-points-to-origin.py
 create mode 100644 problems/python3/task-scheduler.py

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/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/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/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

From 91179a34bf0c718a86696aebf151f5e3e1f45101 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Fri, 2 Sep 2022 11:09:53 +0200
Subject: [PATCH 09/20] updates

---
 problems/python3/merge-intervals.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 problems/python3/merge-intervals.py

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

From dddf785deb5d9faae06e29b008d7a11aea93e6f5 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Fri, 2 Sep 2022 11:10:23 +0200
Subject: [PATCH 10/20] updates

---
 problems/python3/insert-interval.py           | 23 +++++++++++++++++++
 problems/python3/meeting-rooms-ii.py          | 12 ++++++++++
 problems/python3/meeting-rooms.py             | 10 ++++++++
 .../minimum-interval-to-include-each-query.py | 23 +++++++++++++++++++
 problems/python3/non-overlapping-intervals.py | 17 ++++++++++++++
 5 files changed, 85 insertions(+)
 create mode 100644 problems/python3/insert-interval.py
 create mode 100644 problems/python3/meeting-rooms-ii.py
 create mode 100644 problems/python3/meeting-rooms.py
 create mode 100644 problems/python3/minimum-interval-to-include-each-query.py
 create mode 100644 problems/python3/non-overlapping-intervals.py

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/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/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/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

From 5a67c5f093445a44278d7a1e9eeb02c2a5a858fd Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Tue, 20 Sep 2022 07:46:21 +0200
Subject: [PATCH 11/20] updates

---
 problems/python3/clone-graph.py               | 16 ++++++
 problems/python3/course-schedule-ii.py        | 30 +++++++++++
 problems/python3/course-schedule.py           | 23 ++++++++
 ...ign-add-and-search-words-data-structure.py | 33 ++++++++++++
 .../python3/implement-trie-prefix-tree.py     | 26 +++++++++
 problems/python3/max-area-of-island.py        | 23 ++++++++
 problems/python3/number-of-islands.py         | 22 ++++++++
 .../python3/pacific-atlantic-water-flow.py    | 30 +++++++++++
 problems/python3/rotting-oranges.py           | 35 ++++++++++++
 problems/python3/surrounded-regions.py        | 34 ++++++++++++
 problems/python3/walls-and-gates.py           | 29 ++++++++++
 problems/python3/word-search-ii.py            | 54 +++++++++++++++++++
 12 files changed, 355 insertions(+)
 create mode 100644 problems/python3/clone-graph.py
 create mode 100644 problems/python3/course-schedule-ii.py
 create mode 100644 problems/python3/course-schedule.py
 create mode 100644 problems/python3/design-add-and-search-words-data-structure.py
 create mode 100644 problems/python3/implement-trie-prefix-tree.py
 create mode 100644 problems/python3/max-area-of-island.py
 create mode 100644 problems/python3/number-of-islands.py
 create mode 100644 problems/python3/pacific-atlantic-water-flow.py
 create mode 100644 problems/python3/rotting-oranges.py
 create mode 100644 problems/python3/surrounded-regions.py
 create mode 100644 problems/python3/walls-and-gates.py
 create mode 100644 problems/python3/word-search-ii.py

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/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/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/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/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/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/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/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/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-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

From 02d6d3b63e5ffcbb88eb4b893b94499411f7d60b Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Sun, 25 Sep 2022 10:46:21 +0200
Subject: [PATCH 12/20] update

---
 problems/python3/graph-valid-tree.py | 33 ++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 problems/python3/graph-valid-tree.py

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

From 3af72365974096fdff631de776b4a26384012e91 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Sun, 25 Sep 2022 10:46:41 +0200
Subject: [PATCH 13/20] updates

---
 ...ected-components-in-an-undirected-graph.py | 25 +++++++++++++++
 problems/python3/redundant-connection.py      | 32 +++++++++++++++++++
 2 files changed, 57 insertions(+)
 create mode 100644 problems/python3/number-of-connected-components-in-an-undirected-graph.py
 create mode 100644 problems/python3/redundant-connection.py

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/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

From 79b9b8fa5bfb8535c9e129e56ce8b882c6111aa7 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Sat, 8 Oct 2022 10:26:40 +0200
Subject: [PATCH 14/20] updates

---
 problems/python3/alien-dictionary.py          | 36 +++++++++++++++++
 .../cheapest-flights-within-k-stops.py        | 17 ++++++++
 problems/python3/climbing-stairs.py           | 10 +++++
 problems/python3/min-cost-climbing-stairs.py  | 16 ++++++++
 .../python3/min-cost-to-connect-all-points.py | 28 +++++++++++++
 problems/python3/network-delay-time.py        | 23 +++++++++++
 problems/python3/reconstruct-itinerary.py     | 27 +++++++++++++
 problems/python3/swim-in-rising-water.py      | 23 +++++++++++
 problems/python3/word-ladder.py               | 40 +++++++++++++++++++
 9 files changed, 220 insertions(+)
 create mode 100644 problems/python3/alien-dictionary.py
 create mode 100644 problems/python3/cheapest-flights-within-k-stops.py
 create mode 100644 problems/python3/climbing-stairs.py
 create mode 100644 problems/python3/min-cost-climbing-stairs.py
 create mode 100644 problems/python3/min-cost-to-connect-all-points.py
 create mode 100644 problems/python3/network-delay-time.py
 create mode 100644 problems/python3/reconstruct-itinerary.py
 create mode 100644 problems/python3/swim-in-rising-water.py
 create mode 100644 problems/python3/word-ladder.py

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/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/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/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/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/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/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

From 82ca4d9a5ff1a4e3efce92cfaa0bc067394e16dc Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Tue, 1 Nov 2022 08:24:43 +0100
Subject: [PATCH 15/20] updates

---
 problems/python3/coin-change.py               | 14 ++++++
 problems/python3/decode-ways.py               | 14 ++++++
 problems/python3/house-robber-ii.py           | 18 ++++++++
 problems/python3/house-robber.py              | 17 +++++++
 .../python3/longest-common-subsequence.py     | 16 +++++++
 .../python3/longest-palindromic-substring.py  | 45 +++++++++++++++++++
 problems/python3/maximum-product-subarray.py  | 25 +++++++++++
 problems/python3/palindromic-substrings.py    | 16 +++++++
 .../python3/partition-equal-subset-sum.py     | 20 +++++++++
 problems/python3/unique-paths.py              | 11 +++++
 problems/python3/word-break.py                | 23 ++++++++++
 11 files changed, 219 insertions(+)
 create mode 100644 problems/python3/coin-change.py
 create mode 100644 problems/python3/decode-ways.py
 create mode 100644 problems/python3/house-robber-ii.py
 create mode 100644 problems/python3/house-robber.py
 create mode 100644 problems/python3/longest-common-subsequence.py
 create mode 100644 problems/python3/longest-palindromic-substring.py
 create mode 100644 problems/python3/maximum-product-subarray.py
 create mode 100644 problems/python3/palindromic-substrings.py
 create mode 100644 problems/python3/partition-equal-subset-sum.py
 create mode 100644 problems/python3/unique-paths.py
 create mode 100644 problems/python3/word-break.py

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/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/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/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-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/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/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/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/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

From bcef8a4a0835589cc686a72614455ac723caef94 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Sun, 27 Nov 2022 10:41:31 +0100
Subject: [PATCH 16/20] updates

---
 ...ime-to-buy-and-sell-stock-with-cooldown.py | 16 ++++++++
 problems/python3/burst-balloons.py            | 28 ++++++++++++++
 problems/python3/coin-change-ii.py            | 12 ++++++
 problems/python3/counting-bits.py             |  9 +++++
 problems/python3/distinct-subsequences.py     | 17 +++++++++
 problems/python3/edit-distance.py             | 37 +++++++++++++++++++
 problems/python3/interleaving-string.py       | 13 +++++++
 .../longest-increasing-path-in-a-matrix.py    | 26 +++++++++++++
 problems/python3/number-of-1-bits.py          | 10 +++++
 .../python3/regular-expression-matching.py    | 24 ++++++++++++
 problems/python3/reverse-bits.py              |  7 ++++
 problems/python3/single-number.py             | 15 ++++++++
 problems/python3/target-sum.py                | 25 +++++++++++++
 13 files changed, 239 insertions(+)
 create mode 100644 problems/python3/best-time-to-buy-and-sell-stock-with-cooldown.py
 create mode 100644 problems/python3/burst-balloons.py
 create mode 100644 problems/python3/coin-change-ii.py
 create mode 100644 problems/python3/counting-bits.py
 create mode 100644 problems/python3/distinct-subsequences.py
 create mode 100644 problems/python3/edit-distance.py
 create mode 100644 problems/python3/interleaving-string.py
 create mode 100644 problems/python3/longest-increasing-path-in-a-matrix.py
 create mode 100644 problems/python3/number-of-1-bits.py
 create mode 100644 problems/python3/regular-expression-matching.py
 create mode 100644 problems/python3/reverse-bits.py
 create mode 100644 problems/python3/single-number.py
 create mode 100644 problems/python3/target-sum.py

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/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/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/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/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/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/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/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/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/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/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/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

From f14be0f429850344c738edc9f18e35e561c724d1 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Thu, 1 Dec 2022 08:00:24 +0100
Subject: [PATCH 17/20] updates

---
 README.md                               |  1 +
 problems/python3/missing-number.py      | 12 ++++++++++++
 problems/python3/reverse-integer.py     | 16 ++++++++++++++++
 problems/python3/sum-of-two-integers.py | 12 ++++++++++++
 4 files changed, 41 insertions(+)
 create mode 100644 problems/python3/missing-number.py
 create mode 100644 problems/python3/reverse-integer.py
 create mode 100644 problems/python3/sum-of-two-integers.py

diff --git a/README.md b/README.md
index 8e05de7..28486a9 100755
--- a/README.md
+++ b/README.md
@@ -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)).
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/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/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

From dbaa78d7677b5e6092997972188e2b5d1266e3d7 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Mon, 5 Dec 2022 08:15:04 +0100
Subject: [PATCH 18/20] updates

---
 problems/python3/rotate-image.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 problems/python3/rotate-image.py

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

From 733fd02cce36af2ae8f2bf0689f4eda5cab90917 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Mon, 5 Dec 2022 08:15:18 +0100
Subject: [PATCH 19/20] updates

---
 problems/python3/set-matrix-zeroes.py | 28 +++++++++
 problems/python3/spiral-matrix.py     | 90 +++++++++++++++++++++++++++
 2 files changed, 118 insertions(+)
 create mode 100644 problems/python3/set-matrix-zeroes.py
 create mode 100644 problems/python3/spiral-matrix.py

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/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

From 74a34466d44007399b6b67a051f0fcd800595ee8 Mon Sep 17 00:00:00 2001
From: wuduhren <wuduhren@outlook.com>
Date: Wed, 21 Dec 2022 08:11:55 +0100
Subject: [PATCH 20/20] update

---
 problems/python3/detect-squares.py   | 22 ++++++++++++++++++++++
 problems/python3/happy-number.py     | 17 +++++++++++++++++
 problems/python3/multiply-strings.py | 22 ++++++++++++++++++++++
 problems/python3/plus-one.py         | 16 ++++++++++++++++
 problems/python3/powx-n.py           | 14 ++++++++++++++
 5 files changed, 91 insertions(+)
 create mode 100644 problems/python3/detect-squares.py
 create mode 100644 problems/python3/happy-number.py
 create mode 100644 problems/python3/multiply-strings.py
 create mode 100644 problems/python3/plus-one.py
 create mode 100644 problems/python3/powx-n.py

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/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/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/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